Operators

Unary Operators

Reduction Operators

Reduction operators apply the corresponding logic operation across all bits of the operand, returning a single bit result.

 module Test(clk: clock) -> () {
    let all_ones = andr 8'b11111111
    $assert(all_ones == 1)

    let any_one = orr 8'b00000001
    $assert(any_one == 1)

    let parity = xorr 8'b10101010
    $assert(parity == 0)
 }

Binary Operators

Arithmetic Operators

Bitwise Operators

Note 1: When the shift amount (the right hand side) in a shr operation is signed (sint type), the operation corresponds to an arithmetic shift right.

Note 2: The and, or, xor, nand, nor, and xnor operators are used both to perform bitwise and logical operations.

Comparison Operators

Ternary Operator

The ternary operator is a concise way to express conditional expressions, generally spanning a single line.

 module Test(a: uint<8>, b: uint<8>) -> () {
    let max = a >= b ? a : b
 }

Concatenation

Integer concatenation can be performed by wrapping a list of values in curly braces:

 module Test(clk: clock) -> () {
    let upper_nibble = 8'hAB
    let lower_nibble = 8'hCD
    let word = {upper_nibble, lower_nibble}
    $assert(word == 16'hABCD)
 }

The concatenation operator also accepts Vectors of integers.

 module Test(clk: clock) -> () {
    let value = {[1'1, 1'0, 1'0, 1'0]} // 4'b1000
    $assert(value == 4'b1000)
 }

Slicing and Indexing

Elements of vectors and bits of integers can be accessed using the [] operator:

 module Test(clk: clock) -> () {
    let bits = [..8'd233]
    let first = bits[0]     // Access the first element
    let nibble = bits[7:4] // Extract a range of bits (inclusive)
    let byte = bits[7-:8]   // Extract 8 bits starting from bit 7 (equivalent to data[7:0])

    $assert(first == 1'b1)
    $assert(uint(nibble) == 4'hE)
    $assert(uint(byte) == 8'hE9)
 }

There are two forms of bit slicing:

1. [high:low] - Extract bits from position high down to low (inclusive)
2. [start-:width] - Extract width bits starting from position start

Note:

• Integers are indexed from the least significant bit (LSB) to the most significant bit (MSB) (right to left).
• Vectors follow standard array-indexing conventions, with the first element at index 0 (left to right).

When a bit vector (bool[N] i.e. uint<1>[N]) is used as the argument of the uint and sint built-in functions, the first element of the vector becomes the MSB of the resulting integer:

 module Test(clk: clock) -> () {
    let n = uint([1'b1, 1'b0, 1'b0])
    $assert(n == 3'b0001)
 }

Replication

Replication expressions <uint>*[<expr-list>] and <uint>*{<expr-list>} create a vector by repeating a value multiple times:

 const a = 1'b1
 const b = 1'b0
 module Test(clk: clock) -> () {
    let zeros = 4*[1'b0]   // Expands to [1'b0, 1'b0, 1'b0, 1'b0]
    let ones = 3*{1'b1} // Expands to {1'b, 1'b, 1'b1}

    $assert(uint(zeros) == 4'd0)
    $assert(uint(ones) == 3'b111)
 }

The repeated expressions can contain any value, including instances:

 module Cell(clk: clock, rst: bool) -> () {}
 const Rows = 1
 const Cols = 1

 module Test(clk: clock, rst: bool) -> () {
    // initialise a Rows by Cols grid of cells
    let cells = Cols * [Rows * [Cell(clk, rst)]]
 }

Concatenation

Concatenation expressions {<expr-list>} create an integer from a list of smaller integers. The width of the resulting integer is the sum of the widths of the operands.

If any operand is a signed integer (sint), then all operands are required to be signed.

 module Test(clk: clock) -> () {
    let concat_args = {16'hBABA, 16'hFABE}
    let concat_vec = {[16'hBABA, 16'hFABE]}

    $assert(concat_args == 32'hBABAFABE)
    $assert(concat_vec == 32'hBABAFABE)
 }

Spread

The spread operator .. can only appear inside a vector expression and is used to decompose a value into its individual elements.

 module Test(clk: clock) -> () {
    let bits: uint<1>[4] = [..4'b1100] // [1'b0, 1'b0, 1'b1, 1'b1]
    let chars: uint<8>[3] = [.."Yo!"] // [8'h59, 8'h6F, 8'h21]
    let flat: uint<2>[3] = [..[2'd1, 2'd2], 2'd3] // [2'd1, 2'd2, 2'd3]

    $assert(bits[0] == 1'b0)
    $assert(bits[1] == 1'b0)
    $assert(bits[2] == 1'b1)
    $assert(bits[3] == 1'b1)
    $assert(chars[0] == 8'h59)
    $assert(chars[1] == 8'h6F)
    $assert(chars[2] == 8'h21)
    $assert(flat[0] == 2'd1)
    $assert(flat[1] == 2'd2)
    $assert(flat[2] == 2'd3)
 }

Operator Precedence

Operators are evaluated in the following order (from highest to lowest precedence):

1. Unary operators (not, -, andr, orr, xorr)
2. Multiplication, division, modulo (*, /, mod)
3. Addition, subtraction (+, -)
4. Shift operations (shl, shr)
5. Comparisons (<:, >:, <=, >=)
6. Equality operators (==, !=)
7. Bitwise AND and NAND (and, nand)
8. Bitwise XOR and XNOR (xor, xnor)
9. Bitwise OR and NOR (or, nor)

Parentheses can be used to override the default precedence order.

Resulting Type

The output type of a binary operation is determined by the types of the operands and the operation being performed.

It matches the FIRRTL specification

The following table summarises the resulting type for each operation:

Shift Operations

When the shift amount is known at compile time, the output type is determined as follows:

When the shift amount is not known at compile time, the output type is determined as follows: