Skip to content

Releases

Volt 0.1.2

Choose a tag to compare

@github-actions github-actions released this 13 Nov 09:38
56e9d97

Volt 0.1.2 fixes bugs of 0.1.1 that produced wrong SystemVerilog, or
skipped a safety check, without a diagnostic: the design compiled, and
the generated hardware did something other than what the source says.
The bugs fall into five groups:

  • wrong constant values: integer literals of 2¹²⁷ and above were
    written as 2¹²⁷ - 1, a negative literal that does not fit its type was
    written as a different positive number, and a generic argument too
    wide for its parameter was passed on unchecked;
  • wrong module bodies and lost files: a generic instance could be
    bound to the body of another generic module, and two modules whose
    names differ in letter case alone wrote one file;
  • lost errors: a warning could swallow the error right after it, so a
    source with a syntax error compiled and parts of it (contracts,
    registers, stall logic) disappeared;
  • skipped checks: the field shorthand S { x } and Inst { x }
    skipped the type, clock domain, trust, handshake and timing checks;
  • checks that stopped at submodules: a clock-domain crossing through
    a module without a clock, and a ready-to-valid path through a
    submodule, got no error.

Upgrading is recommended. Most of these fixes reject input that 0.1.1
accepted; in each such case the 0.1.1 output was wrong. One rule changed:
a clockless extern module is now taken to connect every output to
every input (see
Clock domains through submodules).
The release also adds warning W2016, which marks arithmetic whose value
changes in 0.2.0. Read Behavior changes before
upgrading, and the security issue under Known issues before
you build a repository that you did not write.

Behavior changes

Upgrading from 0.1.1: for each item below, the same input gives a
different result in 0.1.2. Where 0.1.1 compiled a design and 0.1.2
reports an error or writes different SystemVerilog, the 0.1.1 output went
against the language specification, with one exception: the new worst-case
reading of a clockless extern module, which can reject a design that
was correct.

Literals

  • Integer literals of 2¹²⁷ and above are written with their value
    (#207). 0.1.1 wrote every
    literal between 2¹²⁷ and 2¹²⁸ - 1 as 128'h7FFF…FFFF: a reset value,
    a mask or a comparison such as
    a == 0x8000_0000_0000_0000_0000_0000_0000_0001 as bits<128> compared
    with the wrong number, also in a bits<256> context. A generic argument
    of that size became 2¹²⁷ - 1 in the body: with
    module G<const K: uint<128>>, the instance
    G<0x8000_0000_0000_0000_0000_0000_0000_0001> (2¹²⁷ + 1) saw 2¹²⁷ - 1.
    Literals below 2¹²⁷ are written as before.

    • Inside a const expression a literal of 2¹²⁷ or more is now error
      E2022. 0.1.1 read it as another value there:
      const K : u64 = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF / 0x1_0000_0000_0000_0001
      (2¹²⁸ - 1 divided by 2⁶⁴ + 1) was 0 at compile time, and volt build
      stopped with an E0003 that did not say why. The literal -2¹²⁷ in a
      const expression is no longer E2022; a constant that uses it still
      gets E0003 where it is written into the SystemVerilog.
    • A literal in a signed context wider than 128 bits, as in
      -(a * b) > -0x8000_0000_0000_0000_0000_0000_0000_0000 (-2¹²⁷) with
      i64 operands, is written correctly. 0.1.1 wrote it as -(2¹²⁷ - 1),
      and a debug build of the compiler stopped on it.

    What to do: nothing for designs that compile. If a const now gets
    E2022, keep the literals of the constant expression below 2¹²⁷.

  • A negative literal must fit its type
    (#213). -<literal> is
    checked like a literal without a sign. 0.1.1 wrote b : i8 = -129 as
    +127, compiled i < -500 (i : i8) as i < 12, a reset value
    reg r : i8 = -200 as +56, i + -300 as i - 44, a : u8 = -1 as
    255, and a match arm -5 => on an i3 as 3. These are now E2010:
    "literal expression evaluates to -129, which does not fit in type i8
    (-128..=127)". -2¹²⁷ does not fit i64: E2010.
    What to do: widen the type or change the literal; the error says the
    range. Negative literals that fit compile as before.

  • Literal expressions are range-checked in contexts of 127 bits and
    more
    (#272). 0.1.1 did
    not check them at these widths: a * b == -1 with u64 operands (a
    128-bit context) compiled and compared with 2¹²⁸ - 1. It is now
    E2010.
    What to do: write a value the type can hold.

  • A const generic argument must fit its parameter's type
    (#262). With
    module G<const K: u64>, 0.1.1 accepted
    G<0xFFFF_FFFF_FFFF_FFFF_FFFF> and the hardware saw an 80-bit value.
    This is now E2010 ("generic argument … does not fit in the parameter
    K : u64 of G"), for uN, iN, uint<W> and sint<W> parameters,
    where W is a literal or an earlier const parameter
    (<const W: u32, const K: uint<W>> with G<4, 16> is E2010).
    What to do: pass a value that fits, or declare the parameter with a
    wider type.

  • A pipeline stage offset is read like any integer literal
    (#263): stage(-0x1) is
    stage(-1). 0.1.1 read decimal offsets and nothing else: stage(-0x1)
    got E5012, and stage(+0x1) or an offset larger than i64 stopped a
    debug build of the compiler. An offset that lands on no stage is
    E5012.
    What to do: nothing; a hexadecimal or binary offset now works.

  • A literal cast that does not fit its target warns
    (#207). 0x1FF as bits<8>
    and 300 as u8 keep the low bits of the literal (8'hFF, 8'h2C), as
    in 0.1.1, and now get W2010; see New warnings. A
    parenthesized negative literal can now be cast: (-128) as i8 is
    −128, (-1) as u8 is 255 with W2010 (0.1.1 rejected both with
    E2005). Without parentheses, -1 as u8 means -(1 as u8) (E2002).
    What to do: write the value that fits (the warning says it), or use a
    wider target. A build that treats warnings as errors may now fail.

Generic modules and module names

  • A generic module instantiated without its generic arguments is an
    error
    (#249). Generic
    parameters have no default value. With module M_1<const C: u32>,
    let q = M_1 { x: x } compiled in 0.1.1: volt build exited with 0 and
    wrote a Top.sv that instantiates a module M_1 that was never
    generated, with a misleading W1006 ("M_1 is never instantiated").
    If another instance built the same name (M<1> builds M_1), the
    instance was silently bound to that body and computed x + 1 instead
    of x ^ C. It is now E2003: "'M_1' expects 1 generic argument(s),
    got 0".
    What to do: write the arguments, M_1<8> { x: x }. Instances of
    modules that are not generic do not change.
  • Two modules whose names differ in letter case alone are an error
    (#250), E1003:
    module names 'Foo' and 'foo' differ only in letter case. Each module
    name becomes file names. With module Foo and module foo, or module m_8
    next to the M_8 that M<8> builds, 0.1.1 wrote one formal/foo.sva
    on every system, so the contracts of one module were missing from
    --emit sva; on Windows and macOS rtl/Foo.sv, constraints/Foo.sdc
    and constraints/Foo.xdc were one file too, and the SystemVerilog of
    one module was lost. The rule covers user modules, generic modules that
    are never instantiated and the names generic instances build.
    What to do: rename one of the modules. Volt does not rename generated
    names itself.
  • Two generic modules that build the same module name are an error
    (#205). A generic instance
    is named <module>_<argument values>: M<1, 8> and M_1<8> are both
    M_1_8. 0.1.1 wrote M_1_8.sv once, with the body of M, and bound
    the second instance to it too: M_1<8> computed x + 1 instead of
    x ^ 8. It is now E1003: "'M_1_8' is the generated module name of
    both M<1, 8> and M_1<8>".
    What to do: rename one of the two generic modules.

Diagnostics

  • A warning no longer swallows the error that follows it
    (#206). In 0.1.1 a warning
    such as W0010 or W0020 hid an error one or two tokens later, and the
    broken source compiled with exit code 0. Some of what this lost:

    • the extra ) in r = a & b | c ) got no E0001, and the
      invariant after it was missing from the generated .sva;
    • an invariant cnt < 200 without its colon, after a line with
      W0010, disappeared;
    • a warning on the last statement of a file hid every error of an
      @mmio module, and the invalid registers were missing from the RTL
      and the drivers; on the last statement of a pipeline it hid the
      E5013 of an invalid stall, and no stall logic was generated;
    • frequency = 100mhz in a domain (the correct form is 100.mhz) got
      W0020 "unknown domain key: 'mhz'", and the clock was constrained
      as 100 Hz (create_clock -period 10000000.000)
      (#223).

    These sources are now rejected with the error's own code (E0001,
    E0015, E5013, …). Several errors in one @mmio module or one
    pipeline are now all reported; 0.1.1 reported the earliest one.
    What to do: fix the reported error. Sources without errors give the
    same SystemVerilog.

  • The field shorthand goes through every check
    (#204). S { x } and
    Inst { x } are now checked exactly like S { x: x } and
    Inst { x: x }. 0.1.1 skipped the type, clock do...

Read more

Volt 0.1.1

Choose a tag to compare

@github-actions github-actions released this 08 Nov 21:53
c33b53d

Volt 0.1.1 fixes bugs of 0.1.0 that produced wrong SystemVerilog without
a diagnostic: the design compiled, and the generated hardware did
something other than what the source says. Upgrading is recommended.

This is a bug-fix release. No rule that decides whether a design is
accepted, or what it computes, changed; the specification gained one
warning (a generic parameter that hides a top-level item now gets
W1002). Some input that 0.1.0 accepted is now rejected, and some input
now gives different SystemVerilog. In all but one of these cases the
0.1.0 result went against the language specification; the exception is a
new limit on long enum constant chains (see Constants).
They are listed under Behavior changes; read that
section before upgrading.

Behavior changes

Upgrading from 0.1.0: for each item below, the same input gives a
different result in 0.1.1. Where 0.1.0 compiled a design and 0.1.1
reports an error or writes different SystemVerilog, the 0.1.0 output went
against the specification: in most cases it computed a wrong value; in
the visibility cases (#139)
it read a name that the file is not allowed to see. The one exception is
under Constants.

Names in inlined functions, generic modules and loops

  • A name in an inlined function body is resolved where the function is
    declared
    (#128). A
    constant in a fn body no longer takes the value of a loop variable
    with the same name around the call. With const I = 1 and
    fn pick(x: [u8; 4]) -> u8 { x[I] }, the call
    for I in 0..4 { ys[I] = pick(xs) } gave ys[k] = xs[k]; it now gives
    ys[k] = xs[1]. The same holds for a constant in a part-select start,
    a range bound, a nested call and a match pattern in the body, and for
    a constant's value (const J = I + 1) read inside a loop over I. A
    block let or a loop variable now also hides an outer name with the
    same spelling in a computed index and in a value. A type width
    (uint<W>) or a constant array (T[i]) in the body is no longer
    rejected with E2005 because the caller has a name W or i.
    What to do: a design that reuses a name of a function body or of a
    constant for a loop variable, a block let or a port may get different
    SystemVerilog; warning W1002 points at these places.

  • An inner declaration hides a generic parameter or a module-level
    for variable
    (#130).
    A block let, a for inside comb or a nested for, or a let in a
    loop body with the name of a generic parameter or a loop variable is no
    longer replaced with the parameter's value. In G<3>,
    comb { let N = s y = N } gave y = 3; it now gives y = s. In
    for i in 0..1 { let i = s y = i }, 0.1.0 wrote y = 0; 0.1.1 writes
    y = s. Two inputs that were rejected now compile:
    comb { for N in 0..2 { ys[N] = N } } in a module with a generic N
    (it was E2006), and the shorthand connection P { i } (it was
    E1001).

  • New W1002 warnings for a name that hides another
    (#130): a module-level
    for variable that hides a top-level item, a port, a module signal or a
    generic parameter; a let in a loop body that hides the loop variable,
    a top-level item or a let of the enclosing body; a generic parameter
    of an instantiated generic module that hides a top-level item; a block
    let or a comb loop variable that hides a generic parameter.
    What to do: rename the inner name. A build that treats warnings as
    errors may now fail.

  • Some inputs that 0.1.0 accepted are now errors
    (#130); in each of them
    the 0.1.0 output used the hidden value (the literal of the generic
    parameter or of the loop, or the top-level constant):

    • a port or a module let with the name of a generic parameter:
      E1003;
    • a module-level loop variable in a pattern, and a block let that
      hides a generic parameter used in a pattern: E1015;
    • a block let that hides a generic parameter used in a type width
      (uint<N>): E2005;
    • a let of a loop body used as a generic argument (W<i>): E2008;
      used in a type width: E2021;
    • a port or a module signal that hides a top-level constant, used in a
      module-level for bound: E2021.

    What to do: give the inner name a name of its own; the error points
    at it.

  • A block let or a loop variable hides a bundle port, an inout
    port, the @mmio handle regs and a pipeline stage value

    (#136,
    #137,
    #138). A use of the name
    now reads the local. After let tx : Flags = ..., tx.fired read the
    port's tx_valid && tx_ready; it now reads the field of the local. The
    same holds for dq.released after let dq : St = ... (it read
    !dq_oe) and regs.control.enable after let regs : Regs = ... (it
    read the register map). In a pipeline stage,
    for a in 0..2 { r[a] <= x } wrote r[a_a_r] twice; it now writes
    r[0] and r[1].

    • The index and the length of a bundle array are evaluated where they
      are used: a port, a module let, a block let or a loop variable
      that hides a top-level constant there is now E2008 (0.1.0 read the
      constant and selected rx[0]).
    • Inferred contracts: a counter or a state machine whose limit or
      written value is a block let no longer gets an inferred contract.
      0.1.0 took the let for the constant it hides and generated an
      invariant that does not hold (a failure in volt test, a
      counterexample in volt verify) or a cover point for a transition
      that does not exist. A match on an enum local that hides the state
      register (comb { let st : Color = c; match st { ... } }) no longer
      removes the cover points of the state machine.
    • A local let with the name of a stage value in the module-level
      comb of a pipeline compiles; it was E5012.
    • New diagnostics: a local that hides a bundle port or regs gets
      W1002; a field access on a u8 local that hides a bundle port is
      E2003; dq.drive(v) on a local that hides an inout port is
      E0001; a write to a field of a local regs is E4001 (it was
      E4006).

    What to do: a design that reuses the name of a port, of regs, of a
    stage value or of a top-level constant in a block may get different
    SystemVerilog and different inferred contracts; the new W1002
    warnings and E2008 errors point at these places.

Visibility across files

  • A constant or a struct of another file needs pub and use in every
    position
    (#139). A
    constant that is not pub or not imported with use, read in a
    module-level for bound or in the length or index of a bundle array,
    and such a struct used as a bundle type or a Handshake payload, are
    now E1001. 0.1.0 read them without a word: with a private K = 1 in
    another file, y = rx[K].data selected rx_1_data. A glob import
    (use a::*) does not bring private items. The body of a generic module
    is resolved in the file that declares it. A constant or bundle type
    imported with use a::X as J now resolves in these positions (it was
    E2008, E2021 or E4001). A loop variable with the name of a hidden
    item of another file no longer gets W1002.
    What to do: a new E1001 says that the file that uses the name does
    not see it. Make the item pub in the file that declares it, and add
    use package::Name; to the file that uses it.

Widths

  • The untyped let of an inlined function keeps its flexible width in
    a comb block
    (#132),
    as it already did at module level and now also in a for inside a
    block, a contract and a register's reset value. With
    fn g(a: u8, b: u8, c: u8) -> u9 { let s = a + b; (s | c) + c } and
    a = b = c = 255, comb { x = g(a, b, c) } gave 254 and the
    module-level y = g(a, b, c) gave 510; both now give 510. Some designs
    of the same kind stopped volt test with a Verilator width warning
    ((s | c) as u16); they now simulate.
    What to do: the SystemVerilog of a fn called from comb whose
    untyped let is used in a narrower operation changes. No source change
    is needed.

Literal arithmetic

  • Arithmetic on literals alone is computed at compile time with its
    exact value
    (#144,
    #152,
    #153): arithmetic whose
    operands are all literals, generic parameters or loop variables of a
    for inside comb. The result is written as one literal. 0.1.0 cut every literal
    to the width of its context and left the operation to SystemVerilog:
    y : u2 = 7 / 3 was written 2'h3 / 2'd3 (1) and is now 2'd2;
    x == 7 / 3 and x < 5 % 3 compared with a wrong value. New errors:

    • E2010 when the result does not fit its target:
      y : u2 = 5 + 2, const X : u8 = 200 + 100, x < 3 - 1 with
      x : u1. 0.1.0 wrapped the value without a word. The same for a
      comb loop variable that does not fit (ys[i] = i where i goes
      past the range of the target); every combination of nested loops is
      checked.
    • E2023 for a division or a remainder by zero: 7 / 0,
      5 % (2 - 2).

    What to do: if the build now reports E2010 or E2023, the 0.1.0
    SystemVerilog of that line already computed a wrong value. Widen the
    target, or fix the constant; the help line of the error says how.

Constants

  • A match on an enum constant defined through a chain of more than 63
    constants
    (`const A0 : E...
Read more

Volt 0.1.0

Choose a tag to compare

@github-actions github-actions released this 04 Nov 13:23
5eff136

Volt is a hardware description language with a Rust-like syntax. It
compiles to SystemVerilog and checks clock and reset domains in its type
system: a clock domain crossing without a synchronizer is a compile error.

0.1.0 is the earliest Volt release. It makes no stability promise: the
syntax, the diagnostic codes and the generated SystemVerilog may change in
0.2 and later (see Support).

A terminal: volt check reports error E3001 on crossing.volt, the sync() line from its help line is added in nano, and volt check reports 0 errors

The recording above: volt check reports an unsynchronized crossing, and
the sync() line from its help message fixes it
(the code,
the recording script).
The book: https://volt-hdl.github.io/volt/.

Behavior changes

There is no earlier release to compare with. The changes below matter if
you built Volt from the main branch before this release: the same input
now gives a different result.

Clock and reset domains

  • A flip-flop clocked from a domain declared with clock = none (a domain
    with no clock edge) is now error E3016: in an on block, as a
    sync() destination, on the clock port of a built-in component or a
    submodule, and as the sampling clock of contracts. It used to compile to
    a posedge flip-flop. Combinational signals in such a domain, and
    sync() from it (an asynchronous input), are still accepted.
  • An on block whose trigger is not a clock port (on d with
    d : bool), and two clock ports annotated with each other's domain,
    are now error E3002, reported by volt check and the editor as well
    as by volt build. SystemVerilog generation derives the clock edge and
    the reset branch of every flip-flop from the source and no longer
    assumes them.
  • A clock port annotated with the domain of another clock port
    (in c2 : clock @c1) takes that clock's domain, in any port order.
    When c1 is in a domain whose edge is negedge, the flip-flops of
    on c2 are now negedge; they used to be posedge.
  • New warning W3011: a raw reset port that reaches the module's
    registers through a release synchronizer is also connected to an
    extern instance, which gets the unsynchronized reset. The output does
    not change.

Registers, wires and let

  • Writing a wire or an out port with <= inside an on block is now
    error E0020. It used to produce a flip-flop with an empty reset
    branch, which kept its old value through reset. The suggestion rewrites
    the signal as a register with a reset value.
  • An untyped let takes the natural width of its expression: with a
    and b of type u8, let s = a + b is now 9 bits wide (it was 8, so
    255 + 1 gave 0). * doubles the width; a unary - turns iN into
    i(N+1). Code that relies on wrap-around writes the type:
    let addr : u32 = pc + 4.
  • An untyped literal let (let k = 100) now compiles, with warning
    W2012, as an i32. It used to fail with E2005. A literal that does
    not fit in an i32 is E2010.
  • An untyped let whose carry bit a comparison reads no longer gets the
    comment // carry bit of '...' unused and an UNUSEDSIGNAL lint waiver
    in the generated SystemVerilog. Both were wrong: the carry bit is used.

Comparisons

  • Comparing two values whose natural widths differ is now error E2031.
    With a and b of type u3, b + 1 is 4 bits wide, and both
    a == b + 1 and let s = b + 1 followed by a == s are rejected. They
    used to compile to different hardware: the inline form wrapped at 3 bits,
    the let form kept the carry, so a = 0, b = 7 gave different
    results. The same rule applies in contracts. A side that is a constant
    known at compile time and fits the other side is accepted
    (count == LIMIT - 1). The help line gives both fixes with as:
    a == (b + 1)[2:0] as u3 wraps, (a as u4) == b + 1 keeps the carry.
  • An accepted comparison is made at the natural width of its sides: with
    c and d of type u8, c + d == 5 keeps the carry (it used to wrap
    at 8 bits), and c + d < 300 compares with 300 (it used to compare with
    8'd300, which is 44).
  • A shift or a ~ inside a wider arithmetic keeps its own width. With
    a of type u8, let w : u12 = (~a) + 0 gives 255 for a = 0; it
    used to give 4095, inverting the upper bits too, without a warning.
    (a << n) + b in a 12-bit let, and a << n assigned to a 12-bit
    output, used to stop volt test with a Verilator width warning.
  • A bit, range or indexed part-select of a computed value, such as
    (a + 1)[3:0] or (a + b)[i +: 4], compiles to valid SystemVerilog
    (4'(9'(a) + 9'd1), 4'((9'(a) + 9'(b)) >> i)), computed at the
    natural width so that the carry can be selected. It used to be
    written as (a + 8'd1)[3:0] or (a + b)[i +: 4], which Verilator and
    Yosys reject.

Expressions and casts

These were found by the differential test of expression semantics, which
compares the generated SystemVerilog, simulated in Verilator, with a
reference model written from the language specification.

  • An as cast that changes the width takes the sign of its target type
    (#115). With a of type i10, a as i11 > 880 is now false for
    a = -1. It used to be true: the sign extension {{1{a[9]}}, a} was
    compared as an unsigned number. It is now written
    $signed({{1{a[9]}}, a}) > 11'sd880. The same mistake made
    s as i50 >> 8 (s : i7) shift in zeros, and -(s as i4)
    (s : i2) give -15 instead of 1 for s = -1.
  • A hexadecimal, binary or octal literal in a signed expression is a
    signed literal (#116). With s of type i50, s > 0x0 is now false
    for s = -1; it used to be true, because 50'h0 made the comparison
    unsigned. It is now written s > 50'sh0. The most negative value of a
    width is written as a bit pattern (8'sh80): with s of type i1,
    (s * (-1)) as u35 gave 34359738367 (all ones) for s = -1 instead
    of 1.
  • A sub-expression whose value depends on its width keeps its value
    inside a wider expression (#117). With a and b of type u8 and
    c of type u9, (a - b) + c assigned to a u10 gave 1023 + c
    for a = 0, b = 1, while let s = a - b followed by s + c gave
    511 + c. Both now give 511 + c: the subtraction is computed at its
    own width, 10'($unsigned(9'(a) - 9'(b))) + 10'(c). The same holds for
    an unsigned subtraction in a wider product or cast, a sum whose carry a
    bitwise operation drops (((a + b) | c) + c), ~ under a cast of the
    same width, -x inside a shift, and the right shift of a sum, which now
    reads the carry ((a + b) >> n).
  • -(-x) compiles to -(-(...)) (#118). It used to be written
    --(...), the SystemVerilog decrement operator, which Verilator
    rejects.
  • A select of a select of a computed value compiles to valid
    SystemVerilog (#119): (q as bits<34>)[28:0][27] is now
    1'((29'(q)) >> 27). It used to be 29'(q)[27], which Verilator and
    Yosys reject.
  • A bit or range select of a one-bit value (u1, i1, bits<1>)
    compiles to the value itself (#120): x[0], x[0:0] and x[0 +: 1]
    are now x. They used to be written as a select of a scalar, which
    Verilator rejects. A select of a signed one-bit value is unsigned
    ($unsigned(x)).
  • The generated SystemVerilog no longer causes Verilator width warnings
    (#123). These warnings are fatal by default, so volt test stopped on
    a valid design. A variable index or part-select start whose width
    differs from the address width of its base is written as a shift: with
    x of type u15 and i of type u3, x[i] is now 1'((x) >> i). A
    widening cast of a computed value is written at the target width:
    (a + b) as i32 is now 32'((32'(a) + 32'(b))) (it was
    32'((a + b))). A literal wider than its context is written as its
    truncated bit pattern (1'h1, not 1'd3). Values do not change,
    except the bits of a variable part-select that fall outside its base:
    they are undefined (x) in the language and now read as 0.

Modules

  • An extern module named like a standard library module (EdgeDetect,
    SyncFifo, Counter, ...), or a Volt module with such a name
    instantiated from another module, is now error E1016. The built-in
    module used to be taken in its place without a word. A top-level module
    with such a name (the Counter of the volt new template) stays valid.

Commands

  • volt check without arguments (project mode) also checks every test
    file that volt test finds, in subdirectories too (build/ is
    skipped), and prints a Checking <file> line for each. A project that
    passed before exits with code 1 if a test file has an error.
  • A test file X_test.volt with no sibling X.volt gets the full check
    in volt check, volt build and the editor, as in volt test: a
    missing module under test is E8501.
  • The Compiling lines of volt test print relative paths without a
    prefix (counter_test.volt, sim/deep_test.volt; it used to print
    .\counter_test.volt).
  • volt --version, volt without arguments, the Version: line of
    generated SystemVerilog and the header of SDC/XDC files name the commit
    the binary was built from: volt 0.1.0 (abcdefg). A binary built
    without git, or from a release source archive, prints the version alone.
  • --color auto|always|never, --no-color and VOLT_COLOR work with
    every command and color error and warning diagnostics. In a terminal,
    diagnostics are colored by default; they are not when the output is not
    a terminal or when NO_COLOR or CI is set. volt check --color used
    to fail with "unexpected argument" (exit code 2).

Highlights

Clock and reset domains in the type system

Every signal belongs to a clock domain. A crossing with...

Read more