Description
The UInt/SInt type corresponds to a vector of bits that can be used for signed/unsigned integer arithmetic.
Declaration
The syntax to declare an integer is as follows: (everything between [] is optional)
| Syntax | Description | Return |
|---|---|---|
| UInt[()] SInt[()] |
Create an unsigned/signed integer, bits count is inferred | UInt SInt |
| UInt(x bits) SInt(x bits) |
Create an unsigned/signed integer with x bits | UInt SInt |
| U(value: Int[,x bits]) S(value: Int[,x bits]) |
Create an unsigned/signed integer assigned with ‘value’ | UInt SInt |
| U”[[size’]base]value” S”[[size’]base]value” |
Create an unsigned/signed integer assigned with ‘value’ (Base : ‘h’, ‘d’, ‘o’, ‘b’) | UInt SInt |
| U([x bits,] element, …) S([x bits,] element, …) |
Create an unsigned integer assigned with the value specified by elements | UInt SInt |
val myUInt = UInt(8 bits)
myUInt := U(2,8 bits)
myUInt := U(2)
myUInt := U"0000_0101" // Base per default is binary => 5
myUInt := U"h1A" // Base could be x (base 16)
// h (base 16)
// d (base 10)
// o (base 8)
// b (base 2)
myUInt := U"8'h1A"
myUInt := 2 // You can use scala Int as literal value
val myBool := myUInt === U(7 -> true,(6 downto 0) -> false)
val myBool := myUInt === U(myUInt.range -> true)
// For assignement purposes, you can omit the U/S, which also alow the use of the [default -> ???] feature
myUInt := (default -> true) //Assign myUInt with "11111111"
myUInt := (myUInt.range -> true) //Assign myUInt with "11111111"
myUInt := (7 -> true, default -> false) //Assign myUInt with "10000000"
myUInt := ((4 downto 1) -> true, default -> false) //Assign myUInt with "00011110"
Operators
The following operators are available for the UInt and SInt type
Logic
| Operator | Description | Return type |
|---|---|---|
| x ^ y | Logical XOR | Bool |
| ~x | Bitwise NOT | T(w(x) bits) |
| x & y | Bitwise AND | T(max(w(xy) bits) |
| x | y | Bitwise OR | T(max(w(xy) bits) |
| x ^ y | Bitwise XOR | T(max(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 | Arithmetic shift right, y : Int | T(w(x) - y bits) |
| x >> y | Arithmetic shift right, y : UInt | T(w(x) bits) |
| x << y | Arithmetic shift left, y : Int | T(w(x) + y bits) |
| x << y | Arithmetic shift left, y : UInt | T(w(x) + max(y) bits) |
| x |>> y | Logical shift right, y : Int/UInt | T(w(x) bits) |
| x |<< y | Logical shift left, y : Int/UInt | T(w(x) bits) |
| x.rotateLeft(y) | Logical left rotation, y : UInt/Int | T(w(x) bits) |
| x.rotateRight(y) | Logical right rotation, y : UInt/Int | T(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 = SInt(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 uint_10bits = uint_8bits << 2 // shift left (result on 10 bits)
val shift_8bits = uint_8bits |<< 2 // shift left (result on 8 bits)
// Logical rotation
val myBits = uint_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
}
Arithmetic
| Operator | Description | Return |
|---|---|---|
| x + y | Addition | T(max(w(x), w(y) bits) |
| x - y | Subtraction | T(max(w(x), w(y) bits) |
| x * y | Multiplication | T(w(x) + w(y) bits) |
| x / y | Division | T(w(x) bits) |
| x % y | Modulo | T(w(x) bits) |
// Addition
val res = mySInt_1 + mySInt_2
Comparison
| Operator | Description | Return type |
|---|---|---|
| x === y | Equality | Bool |
| x =/= y | Inequality | Bool |
| x > y | Greater than | Bool |
| x >= y | Greater than or equal | Bool |
| x < y | Less than | Bool |
| x <= y | Less than or equal | Bool |
// Comparaison between two SInt
myBool := mySInt_1 > mySInt_2
// Comparaison between UInt and a literal
myBool := myUInt_8bits >= U(3, 8 bits)
when(myUInt_8bits === 3){
}
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)) |
| S(x: T) | Cast a Data into a SInt | SInt(w(x) bits) |
| U(x: T) | Cast a Data into an UInt | UInt(w(x) bits) |
To cast a Bool, a Bits or a SInt into a UInt, you can use U(something). To cast things into a SInt, you can use S(something)
// cast a SInt to Bits
val myBits = mySInt.asBits
// create a Vector of bool
val myVec = myUInt.asBools
// Cast a Bits to SInt
val mySInt = S(myBits)
Bit extraction
| Operator | Description | Return |
|---|---|---|
| x(y) | Readbit, y : Int/UInt | Bool |
| x(offset, width) | Read bitfield, offset: UInt, width: Int | T(width bits) |
| x(range) | Read a range of bit. Ex : myBits(4 downto 2) | T(range bits) |
| x(y) := z | Assign bits, y : Int/UInt | Bool |
| x(offset, width) := z | Assign bitfield, offset: UInt, width: Int | T(width bits) |
| x(range) := z | Assign a range of bit. Ex : myBits(4 downto 2) := U”010” | T(range bits) |
// get the element at the index 4
val myBool = myUInt(4)
// assign
mySInt(1) := True
// Range
val myUInt_8bits = myUInt_16bits(7 downto 0)
val myUInt_7bits = myUInt_16bits(0 to 6)
val myUInt_6bits = myUInt_16Bits(0 until 6)
mySInt_8bits(3 downto 0) := mySInt_4bits
Misc
| Operator | Description | Return |
|---|---|---|
| x.getWidth | Return bitcount | Int |
| x.msb | Return the most significant bit | Bool |
| x.lsb | Return the least significant bit | Bool |
| x.range | Return the range (x.high downto 0) | Range |
| x.high | Return the upper bound of the type x | Int |
| x ## y | Concatenate, x->high, y->low | Bits(w(x) + w(y) bits) |
| x @@ y | Concatenate x:T with y:Bool/SInt/UInt | T(w(x) + w(y) bits) |
| x.subdivideIn(y slices) | Subdivide x in y slices, y: Int | Vec(T, y) |
| x.subdivideIn(y bits) | Subdivide x in multiple slices of y bits, y: Int | Vec(T, w(x)/y) |
| x.resize(y) | Return a resized copy of x, if enlarged, it is filled with zero for UInt or filled with the sign for SInt, y: Int |
T(y bits) |
| x.resized | Return a version of x which is allowed to be automatically resized were needed |
T(w(x) bits) |
| myUInt.twoComplement(en: Bool) | Use the two’s complement to transform an UInt into an SInt | SInt(w(myUInt) + 1) |
| mySInt.abs | Return the absolute value of the SInt value | SInt(w(mySInt)) |
| mySInt.abs(en: Bool) | Return the absolute value of the SInt value when en is True | SInt(w(mySInt)) |
myBool := mySInt.lsb // equivalent to mySInt(0)
// Concatenation
val mySInt = mySInt_1 @@ mySInt_1 @@ myBool
val myBits = mySInt_1 ## mySInt_1 ## myBool
// Subdivide
val sel = UInt(2 bits)
val mySIntWord = mySInt_128bits.subdivideIn(32 bits)(sel)
// sel = 0 => mySIntWord = mySInt_128bits(127 downto 96)
// sel = 1 => mySIntWord = mySInt_128bits( 95 downto 64)
// sel = 2 => mySIntWord = mySInt_128bits( 63 downto 32)
// sel = 3 => mySIntWord = mySInt_128bits( 31 downto 0)
// if you want to access in a reverse order you can do
val myVector = mySInt_128bits.subdivideIn(32 bits).reverse
val mySIntWord = myVector(sel)
// Resize
myUInt_32bits := U"32'x112233344"
myUInt_8bits := myUInt_32bits.resized // automatic resize (myUInt_8bits = 0x44)
myUInt_8bits := myUInt_32bits.resize(8) // resize to 8 bits (myUInt_8bits = 0x44)
// Two's complement
mySInt := myUInt.twoComplement(myBool)
// Absolute value
mySInt_abs := mySInt.abs