Description

The Bits type corresponds to a vector of bits that does not convey any arithmetic meaning.

Declaration

The syntax to declare a bit vector is as follows: (everything between [] is optional)

Syntax Description Return
Bits [()] Create a BitVector, bits count is inferred Bits
Bits(x bits) Create a BitVector with x bits Bits
B(value: Int[, x bits]) Create a BitVector with x bits assigned with ‘value’ Bits
B”[[size’]base]value” Create a BitVector assigned with ‘value’ (Base: ‘h’, ‘d’, ‘o’, ‘b’) Bits
B([x bits,] element, …) Create a BitVector assigned with the value specified by elements Bits 
// Declaration
val myBits  = Bits()     // the size is inferred     
val myBits1 = Bits(32 bits)   
val myBits2 = B(25, 8 bits)
val myBits3 = B"8'xFF"   // Base could be x,h (base 16)                         
                         //               d   (base 10)
                         //               o   (base 8)
                         //               b   (base 2)    
val myBits4 = B"1001_0011"  // _ can be used for readability

// Element
val myBits5 = B(8 bits, default -> True) // "11111111"
val myBits6 = B(8 bits, (7 downto 5) -> B"101", 4 -> true, 3 -> True, default -> false ) // "10111000"
val myBits7 = Bits(8 bits)
myBits7 := (7 -> true, default -> false) // "10000000" (For assignement purposes, you can omit the B)

Operators

The following operators are available for the Bits type

Logic

Operator Description Return type
~x Bitwise NOT Bits(w(x) bits)
x & y Bitwise AND Bits(w(xy) bits)
x | y Bitwise OR Bits(w(xy) bits)
x ^ y Bitwise XOR Bits(w(xy) bits)
x.xorR XOR all bits of x Bool
x.orR OR all bits of x Bool
x.andR AND all bits of x Bool
x >> y Logical shift right, y: Int Bits(w(x) - y bits)
x >> y Logical shift right, y: UInt Bits(w(x) bits)
x << y Logical shift left, y: Int Bits(w(x) + y bits)
x << y Logical shift left, y: UInt Bits(w(x) + max(y) bits)
x |>> y Logical shift right, y: Int/UInt Bits(w(x) bits)
x |<< y Logical shift left, y: Int/UInt Bits(w(x) bits)
x.rotateLeft(y) Logical left rotation, y: UInt/Int Bits(w(x) bits)
x.rotateRight(y) Logical right rotation, y: UInt/Int Bits(w(x) bits)
x.clearAll[()] Clear all bits -
x.setAll[()] Set all bits -
x.setAllTo(value: Boolean) Set all bits to the given Boolean value -
x.setAllTo(value: Bool) Set all bits to the given Bool value - 
// Bitwise operator
val a, b, c = Bits(32 bits)
c := ~(a & b) //  Inverse(a AND b)

val all_1 = a.andR // Check that all bit are equal to 1

// Logical shift
val bits_10bits = bits_8bits << 2  // shift left (result on 10 bits)
val shift_8bits = bits_8bits |<< 2 // shift left (result on 8 bits)

// Logical rotation
val myBits = bits_8bits.rotateLeft(3) // left bit rotation

// Set/clear
val a = B"8'x42"
when(cond){
  a.setAll() // set all bits to True when cond is True
}

Comparison

Operator Description Return type
x === y Equality Bool
x =/= y Inequality Bool 
when(myBits === 3){
}

when(myBits_32 =/= B"32'x44332211"){
}

Type cast

Operator Description Return
x.asBits Binary cast in Bits Bits(w(x) bits)
x.asUInt Binary cast in UInt UInt(w(x) bits)
x.asSInt Binary cast in SInt SInt(w(x) bits)
x.asBools Cast into a array of Bool Vec(Bool, w(x))
B(x: T) Cast a Data into Bits  Bits(w(x) bits)

To cast a Bool, UInt or a SInt into a Bits, you can use B(something)

// cast a Bits to SInt
val mySInt = myBits.asSInt

// create a Vector of bool
val myVec = myBits.asBools

// Cast a SInt to Bits
val myBits = B(mySInt)

Bit extraction

Operator Description Return
x(y) Readbit, y: Int/UInt Bool
x(hi,lo) Read bitfield, hi: Int, lo: Int Bits(hi-lo+1 bits)
x(offset,width bits) Read bitfield, offset: UInt, width: Int Bits(width bits)
x(range) Read a range of bit. Ex : myBits(4 downto 2) Bits(range bits)
x(y) := z Assign bits, y: Int/UInt Bool
x(offset, width bits) := z Assign bitfield, offset: UInt, width: Int Bits(width bits)
x(range) := z Assign a range of bit. Ex : myBits(4 downto 2) := B”010” Bits(range bits) 
// get the element at the index 4
val myBool = myBits(4)

// assign
myBits(1) := True

// Range
val myBits_8bits = myBits_16bits(7 downto 0)
val myBits_7bits = myBits_16bits(0 to 6)
val myBits_6bits = myBits_16Bits(0 until 6)

myBits_8bits(3 downto 0) := myBits_4bits

Misc

Operator Description Return
x.getWidth Return bitcount Int
x.range Return the range (x.high downto 0) Range
x.high Return the upper bound of the type x Int
x.msb Return the most significant bit Bool
x.lsb Return the least significant bit Bool
x ## y Concatenate, x->high, y->low Bits(w(x) + w(y) bits)
x.subdivideIn(y slices) Subdivide x in y slices, y: Int Vec(Bits, y)
x.subdivideIn(y bits) Subdivide x in multiple slices of y bits, y: Int Vec(Bits, w(x)/y)
x.resize(y) Return a resized copy of x, if enlarged, it is filled with zero, y: Int Bits(y bits)
x.resized Return a version of x which is allowed to be automatically resized were needed Bits(w(x) bits)
x.resizeLeft(x) Resize by keeping MSB at the same place, x:Int Bits(x bits) 
println(myBits_32bits.getWidth) // 32

myBool := myBits.lsb  // equivalent to myBits(0)

// concatenation
myBits_24bits := bits_8bits_1 ## bits_8bits_2 ## bits_8bits_3

// Subdivide
val sel = UInt(2 bits)
val myBitsWord = myBits_128bits.subdivideIn(32 bits)(sel)
    // sel = 0 => myBitsWord = myBits_128bits(127 downto 96)
    // sel = 1 => myBitsWord = myBits_128bits( 95 downto 64)
    // sel = 2 => myBitsWord = myBits_128bits( 63 downto 32)
    // sel = 3 => myBitsWord = myBits_128bits( 31 downto  0)

 // if you want to access in a reverse order you can do
 val myVector   = myBits_128bits.subdivideIn(32 bits).reverse
 val myBitsWord = myVector(sel)

// Resize
myBits_32bits := B"32'x112233344"
myBits_8bits  := myBits_32bits.resized       // automatic resize (myBits_8bits = 0x44)
myBits_8bits  := myBits_32bits.resize(8)     // resize to 8 bits (myBits_8bits = 0x44)
myBits_8bits  := myBits_32bits.resizeLeft(8) // resize to 8 bits (myBits_8bits = 0x11)
Tags: