veryl-std 0.20.1

A modern hardware description language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

pub package lzc_common_pkg {
    struct result::<N: p32> {
        all_zero: logic           ,
        count   : logic<$clog2(N)>,
    }

    function lzc4 (
        bits: input logic<4>,
    ) -> result::<4> {
        var ret         : result::<4>;
        ret.all_zero = bits == '0;
        ret.count[1] = bits[1:0] == '0;
        ret.count[0] = !(bits[0] || ((!bits[1]) && bits[2]));
        return ret;
    }

    function lzc8 (
        bits: input logic<8>,
    ) -> result::<8> {
        var ret4: result::<4> [2];
        var ret : result::<8>    ;

        ret4[0] = lzc4(bits[0 step 4]);
        ret4[1] = lzc4(bits[1 step 4]);

        ret.all_zero = ret4[0].all_zero && ret4[1].all_zero;
        if !ret4[0].all_zero {
            ret.count = {1'b0, ret4[0].count};
        } else {
            ret.count = {1'b1, ret4[1].count};
        }

        return ret;
    }

    function lzc16 (
        bits: input logic<16>,
    ) -> result::<16> {
        var ret4       : result::<4>     [4];
        var any_one    : logic       <4>    ;
        var ret_any_one: result::<4>        ;
        var ret        : result::<16>       ;

        for i in 0..4 {
            ret4[i]    = lzc4(bits[i step 4]);
            any_one[i] = !ret4[i].all_zero;
        }
        ret_any_one = lzc4(any_one);

        ret.all_zero = ret_any_one.all_zero;
        ret.count    = {ret_any_one.count, ret4[ret_any_one.count].count};

        return ret;
    }

    function lzc32 (
        bits: input logic<32>,
    ) -> result::<32> {
        var ret8       : result::<8>     [4];
        var any_one    : logic       <4>    ;
        var ret_any_one: result::<4>        ;
        var ret        : result::<32>       ;

        for i in 0..4 {
            ret8[i]    = lzc8(bits[i step 8]);
            any_one[i] = !ret8[i].all_zero;
        }
        ret_any_one = lzc4(any_one);

        ret.all_zero = ret_any_one.all_zero;
        ret.count    = {ret_any_one.count, ret8[ret_any_one.count].count};

        return ret;
    }

    function lzc64 (
        bits: input logic<64>,
    ) -> result::<64> {
        var ret8       : result::<8>     [8];
        var any_one    : logic       <8>    ;
        var ret_any_one: result::<8>        ;
        var ret        : result::<64>       ;

        for i in 0..8 {
            ret8[i]    = lzc8(bits[i step 8]);
            any_one[i] = !ret8[i].all_zero;
        }
        ret_any_one = lzc8(any_one);

        ret.all_zero = ret_any_one.all_zero;
        ret.count    = {ret_any_one.count, ret8[ret_any_one.count].count};

        return ret;
    }
}