Skip to content

Releases

xezim-bin 0.11.3

Choose a tag to compare

@github-actions github-actions released this 24 Oct 14:33

Automated build of xezim-bin 0.11.3.

Upstream: https://github.com/aionhw/xezim/releases/tag/0.11.3

Upstream changes

0.11.3 — hierarchy, interfaces, assertions and collection correctness (October 2026)

Correctness

  • A hierarchical name that does not resolve is an elaboration error (§23.8),
    wherever it is written: a read or a write, a continuous assignment, an
    event control, an assertion, a system task argument, or a task or function
    that is never called. The message gives the file and line, the name, the
    scope that does not declare it and the scope the search started from. Such
    a name was accepted silently: a testbench that wrote to a guessed internal
    name (dut.mem_data[3] = ...) ran as if the write had happened, and a read
    returned x. A name inside a generate block a constant rules out is not
    elaborated, so it is not checked. --no-strict turns the check off, for
    designs that relied on the old behaviour.

  • An assertion attempt at time 0 reads default sampled values (§16.5.1): a
    variable's declaration initializer, else its type's default. It read the
    values the time-0 continuous assignments and always_comb blocks had
    already driven, so under a clock that rises at time 0 (an HDL clock, or
    cocotb's Python Clock) such an attempt passed. $past at the next tick
    reads the same samples (§16.9.3).

  • The optional SoA signal store preserves X/Z when a four-state signal starts
    with a known value, and converts both X and Z to zero for explicitly declared
    two-state signals, including vectors wider than 64 bits (§6.11.2).

  • Native case equality sign-extends signed operands of different widths,
    including comparisons against constants, matching four-state execution
    (§11.4.5).

  • Toggle coverage no longer lists the names of the top module's instance
    arrays, instances in generate blocks and generate blocks as 1-bit signals.
    They are scopes, not signals, so their bins could never be covered and the
    top instance's toggle score read low (§23.6). (#441)

  • A value a VPI client writes at time 0 is the toggle-coverage baseline.
    Values written from the end-of-slot callbacks (cbReadWriteSynch,
    cbAtEndOfSimTime) reach toggle coverage and the waveform dumps in their
    own time slot, not the next one. A value written from
    cbStartOfSimulation is evaluated in the time-0 slot even when nothing
    else runs there, so the logic it drives no longer reads x until the next
    slot. cocotb writes its first values from both, so in a design with
    nothing of its own at time 0 every signal those values reached lost its
    first toggle. A toggle is counted once per time slot from the slot's net
    change (§38.36.2, §38.36.3). (#442)

  • Class task handles and local variables remain alive across same-slot
    clocking waits, including guarded waits and cancellation (§14.13).
    (#335, reported by urbanij)

  • Parameterized class constructor statics initialize once per referenced
    specialization before initial blocks, with the declared target type and
    constructor arguments preserved (§6.8, §8.25). (#338, reported by Dragon-Git)

  • FST value records retain their declared widths when runtime storage uses a
    different width. Unsupported variable-length strings are omitted with a
    warning naming them, preserving the rest of the waveform (§6.16, §10.8).
    (#339, reported by Lramseyer)

  • Integer inside constraints evaluate size-cast bounds in the joint
    comparison context and sample uniformly over distinct legal values,
    including overlapping ranges and repeated items. Explicit dist weights
    retain their meaning (§11.4.13, §18.5). (#336, reported by urbanij)

  • Indexed writes create associative entries below dynamic outer dimensions
    in class properties, method locals and struct members, preserving declared
    key types and independent rows through allocation, copying and resizing
    (§7.5, §7.8). Recompile saved designs to refresh their class metadata.
    (#337, reported by Dragon-Git)

  • Named blocking case branches retain their %m scope and disable
    targets across suspension (§9.3, §9.6.2).

  • Variables declared in a for header retain their signed type across
    suspension and restore the enclosing variable when the loop exits (§12.7.1).
    (#341, reported by urbanij)

  • Bit and part writes through locals, formals and instance properties use
    their own storage even when a module variable has the same name (§23.9).
    (#344, reported by akashlevy)

  • Static always block locals retain their values when another task has
    suspended, and concurrent or nested declarations retain independent
    storage, widths, signing and string kinds (§6.21, §13.3).
    (#345, #348 and #350, reported by akashlevy)

  • Compiled typedef locals, formals and results retain their declared width,
    signing and two-state defaults, including scoped aliases and alias chains (§6.18).
    (#362, reported by akashlevy)

  • always waits on clocking events resume after sampling and NBA updates.
    Callback-driven clocks deliver those events in the same slot and preserve
    the slot-entry samples of #1step inputs (§14.4, §14.13, §38.36).
    (#356 and #357, reported by akashlevy)

  • Streaming concatenations read every element of class-member queues and
    arrays, including slices and reversed byte streams (§11.4.14).
    (#340, reported by urbanij)

  • Arrays of module instances split ANSI-port and expression connections,
    preserve declared direction in every dimension, and drive output
    concatenations through their writable parts. Unpacked connections match
    the instances left to left (§23.3.3.5).
    (#342 and #343, reported by akashlevy)

  • Nested packed selections retain declared dimension ranges and struct
    member offsets in locals, formals, results and unpacked-array elements.
    Selected writes to static class properties update their shared storage
    (§7.4.1, §8.9, §11.5.1).
    (#346 and #352–#354, reported by akashlevy)

  • Explicit static subroutine initializers run once before initial processes.
    Static subroutine arrays, queues and associative arrays retain one store
    across calls and recursion (§6.21, §13.3, §13.4).
    (#349 and #355, reported by akashlevy)

  • Unpacked port connections match elements in declaration order, including
    descending and negative ranges, slices and multidimensional arrays (§7.6).
    (#358, reported by akashlevy)

  • Unary minus preserves operand signing and width, packed string literals use
    integral ordering in numeric comparisons, and casts through typedef chains
    retain signing and convert X/Z to zero for two-state targets (§5.9, §6.18,
    §6.24.1, §11.8.1). (#359–#361 and #377, reported by akashlevy)

  • Sampled-value functions retain explicit clocks, independent history depths,
    gated samples and slot-entry values of aggregate fields. Assertion action
    blocks evaluate their gates after NBA updates (§16.9.3).
    (#363, #364, #366 and #370, reported by akashlevy)

  • Fixed-array declaration patterns initialize every element, and whole-array
    nonblocking assignments snapshot their right-hand sides before scheduling
    updates, including negative ranges and multiple dimensions (§10.4.2, §10.9.1).
    (#365 and #381, reported by akashlevy)

  • Long assertion delays and repetitions retain their complete bounds.
    Followed-by properties parse with right association and evaluate alternative
    sequence matches without treating an unmatched antecedent as vacuous success
    (§16.9.2, §16.12.9). (#367 and #375, reported by akashlevy)

  • $finish stops procedural, compiled and callback-driven execution immediately.
    Final procedures run before end-of-simulation callbacks (§9.2.3, §20.2).
    (#371–#373, reported by akashlevy)

  • Generated assertions substitute their genvar values, and unnamed generate
    loops expose canonical scope names in VPI, waveforms and coverage (§27.4, §27.6).
    (#374 and #380, reported by akashlevy)

  • Compiled class methods retain each specialization's local types, widths,
    signing and value sets, including inherited bindings. Qualified built-in
    types remain distinct from typedef names (§8.25).
    (#378, reported by akashlevy)

  • Added regressions for signed inlined input formals and timed loop scope
    cleanup (§12.7.1, §13.5.1). (#376 and #379, reported by akashlevy)

  • Instance arrays resolve parameter-named sizes before expansion, including
    imported, scoped and overridden parameters and multiple dimensions. Interface
    elements retain their clock and reset connections (§7.4.2, §23.3.3.5).
    (#342 and #343, reported by akashlevy)

  • Nonblocking selections of static subroutine locals preserve NBA-region
    ordering, capture indices when scheduled, and retain their declaration-owned
    storage after return or suspension. Partial and delayed writes preserve
    unrelated bits and source order (§6.21, §10.4.2, §23.9).
    (#368, contributed by akashlevy)

  • Nested packed local selections retain enum base ranges, ascending labels,
    partial out-of-range behavior and live static storage. Two-state struct
    members convert X/Z independently of four-state neighbors
    (§6.19, §6.21, §7.4.1, §11.5.1).
    (#369, contributed by akashlevy)

  • Initializers accepted with --relax-implicit-static run once before initial
    processes and retain their values across calls and activations. Design caches
    distinguish this lifetime mode from the default policy (§6.21).
    (#351, reported by akashlevy)

  • Static class calls retain lexical scope and specialization through module
    type parameters, typedef chains, nested classes and instance handles.
    Suspended static tasks retain their bindings, and class event OR waits wake
    once on the selected event (§8.23, §8.25, §9.4.2, §13.4.1, §15.5).
    Recompile saved designs to refresh scoped class metadata.
    (#382, reported by Ganesh-TNL)

  • Randomization callbacks reject tasks, non-void returns and argument lists
    before execution, preserving legal inherited and overridden callbacks
    (§18.11). (#383, reported by rpjayaraman)

  • Unsigned expression context rea...

Read more

xezim-bin 0.11.3.40208794201

Pre-release

Choose a tag to compare

Automated build of xezim-bin 0.11.3.40208794201.

Input changes since last release

  • xezim: 0.11.0 -> 0.11.3

xezim-bin 0.11.1

Choose a tag to compare

@github-actions github-actions released this 07 Oct 12:17

Automated build of xezim-bin 0.11.1.

Upstream: https://github.com/aionhw/xezim/releases/tag/0.11.1

Upstream changes

0.11.1 — complete VPI, faster memory models, IEEE 1800 conformance fixes (October 2026)

Correctness

  • A loop variable declared in for (int i = ...) or foreach (arr[k]) no
    longer binds to a same-named variable in a child instance: the loop runs on
    its own storage. It used to read the child's x and run zero iterations, or
    step the child's counter. A bare name also no longer follows an earlier
    hierarchical reference such as u.x = 1 down into that child. (#195, from
    PR #196 by Ganesh T S)
  • A member access through a struct no longer lands on an unrelated class
    object whose handle number happens to equal the struct's value: the path is
    chosen from the declared type. This covers struct variables, collections of
    structs, hierarchical references, ref formals and part-selects, a
    module-level struct holding a class handle, and class handles declared
    through a typedef (including a parameterized one). (#193, from PR #194 by
    Ganesh T S)
  • Members of a struct-typed class property resolve at any depth: indexed and
    part-selected members, nested structs, and queue, dynamic and associative
    array members, in methods and at module scope. (#197, from PR #198 by
    Ganesh T S)
  • A class that extends a parameterized class without giving all its
    parameters (class d extends base;) gets their declared defaults, in
    functions and tasks alike. A type parameter used to read as a 1-bit
    logic, so a UVM base test built this way created null objects and drove
    nothing. (PR #199 by eenky)
  • +incdir+ directories in a -F args file resolve against the file's own
    directory first, so +incdir+. means that directory. (PR #200 by Francesco
    Urbani)
  • --dpi-lib libraries are loaded into the global symbol scope, as the DPI
    guide says, so one library can call another, in either command-line order.
    A call into a second library used to end the run with symbol lookup error. (#202)
  • A --dpi-lib library that cannot be loaded stops the run before it starts
    (exit 1), and calling a DPI import that no loaded library defines is a
    Fatal. Both used to continue, with the import returning 0, and exit 0.
    (#201)
  • $display output from a testbench that prints rarely appears as it is
    printed, not only at exit. (xezim-core #49)
  • A task enabled without parentheses through a hierarchical path or a
    package scope (u.t;, a.b.t;, pkg::t;) is called. It used to be
    dropped inside a task, so an always calling that task spun at time 0
    and the run hung, and directly in an always it was rejected as having no
    timing control. A three-level enable inside a task (a.b.t();) also kept
    advancing time after $finish.
  • An exported task called from C returns only when it has finished:
    fork ... join, join_any, wait fork, wait(...) and @(...) inside it
    now wait, with the rest of the simulation running meanwhile. fork ... join
    used to drop the rest of the task and return, and the others returned at
    once. (#204)
  • wait(ev) on a named event waits for a new trigger every time. After the
    event's first trigger it used to fall straight through.
  • VPI: vpi_mcd_open, vpi_mcd_close, vpi_mcd_flush, vpi_mcd_name,
    vpi_mcd_vprintf, vpi_flush, vpi_compare_objects and vpi_get64 are
    available, and vpi_mcd_printf writes to files opened with vpi_mcd_open
    or $fopen instead of only stdout. The DPI guide lists the VPI calls that
    are still missing. (#205)
  • vpi_get(vpiTimeUnit, ...) and vpi_get(vpiTimePrecision, ...) return a
    module's own timescale for a module handle (the two names are now defined in
    vpi_user.h), and svGetTime, svGetTimeUnit and svGetTimePrecision
    give the same answers from DPI code. (#206)
  • Gate primitives, #(rise, fall) gates, UDP instances with parameter
    delays and wire #d w = expr; inside sub-module instances keep their
    delays, resolved per instance in the child's timeunit; a sub-module buf
    turns z into x as at top level.
  • always @(m[i]) fires in designs that also declare an array of more than
    100,000 elements; every array allocated after the large one used to lose
    element sensitivity.
  • Ports with no data type, and ANSI input logic / inout logic ports, are
    nets (§23.2.2.3); a hierarchical assign dut.u.clk = ... onto a net-typed
    port chain drives it. A continuous assign that only reads an unpacked-array
    element no longer creates a phantom 1-bit net named after the array.
  • The one-time notes for ignored system tasks (such as $dumpfile without
    --wave) are written to stderr as one piece, so $display output going to
    the same file can no longer land inside one and hide a UVM message from log
    parsers.
  • Continuous assigns to a bit or part of an unpacked-array element
    (assign r[i][j] = ..., .out(r[i][j])) drive the array inside
    instantiated modules. They used to be dropped silently there, which left
    the c906 interrupt controller's gated clocks dead. Writes to a bit of a
    2-D or deeper array element (m[i][j][k] = ...) are no longer dropped
    either, at the top level or in procedural code.
  • A net delay (wire #2 w;, #(rise, fall, off), #(P)) delays every
    driver of the net: separate assigns, ports, gates and UDPs. It acts after
    the drivers' own delays and after resolution, bit by bit on a vector. A
    declaration assignment's delay stays that assignment's own. A port bound to
    a net takes the external net's delay. Each of several drivers on one net
    keeps its own delay, and driven tri0/tri1 nets start at x.
  • An undriven output port with no data type (output o, output [3:0] o,
    non-ANSI output o;) floats at z. It used to start at x.
  • @(mem[5]), @(mem[i]) and @(posedge mem[i][0]) on a large memory wake,
    in always blocks and in procedural waits alike, and continuous assigns and
    always_comb blocks reading an element follow writes to it. The event was
    dropped. An event on a select (v[3], v[5:4], m[i]) is an event on the
    selected value: edges are judged on the selected bit, and a changed index
    re-selects the element. posedge v[P-1] with a parameter index watches the
    right bit.
  • A class parameter default is evaluated in the class's own scope, so
    int D = W*2 and type U = T follow the parameters before them in every
    specialization, including typedefs, extends clauses, parameterized
    subclasses and static calls. Specializations that differ only in defaulted
    parameters share statics. Named class parameter assignment (C #(.W(5)))
    binds by name, $typename lists every parameter, and a class variable
    declared in an instantiated module keeps its specialization.
  • A virtual interface reached through any receiver works: class-handle chains
    (cfg.vif, a.cfg.vif, this.cfg.vif), local and formal handles,
    module-scope chains, inherited, parameterized, static and typedef'd
    properties, and vif arrays and queues. This holds for reads, writes,
    nonblocking writes, @(...), wait(...), clocking blocks, interface task
    and function calls, and binding. They used to read 0 or x, drop writes and
    never wake. @(vif.cb) in a class method resumes after the clocking block
    samples. (From PR #207 by eenky)
  • A call in receiver position (get_obj().x, q.pop_front().addr) runs
    once. It used to run up to 12 times, and q.pop_front().addr drained the
    queue.
  • Unpacked-struct members with two or more unpacked dimensions
    (bit [7:0] m [2][2]) survive whole-struct copies (module, block-local,
    nested, array, queue and associative-array elements, class properties),
    struct formals of every direction, function returns, assignment patterns and
    %p. Only the first dimension used to be seen, so the member read as x
    or 0. A nonblocking whole-struct assignment b <= a updates every member;
    it used to get even scalar members wrong. Struct input ports and struct
    continuous assigns carry array members, patterns and %p follow a
    descending dimension's declared order, 2-state array members default to 0,
    num() on an associative array of structs counts keys, and
    $size/$bits work on a member sub-array such as s.mm[1].
  • A UVM DPI library built from include/uvm_dpi_xezim.cc loads. The UVM
    sources it compiles call the SV export m__uvm_report_dpi, and built as
    C++ that call was mangled, so --dpi-lib stopped with undefined symbol.
    The driver now gives everything C linkage, as the reference uvm_dpi.cc
    does, and also builds as C. (#208)
  • An input port whose connection computes something (.p(a & b)) is a net
    of its own (§23.3.3), so @(p) no longer wakes when an operand changes
    while a & b stays the same. A child reached through a select
    (.wl(wl[1])) whose own port has the same name latches again.
  • Inlined task bodies no longer see the caller's local variables, an output
    argument is copied back into the caller's own variable, disable of a task
    inside foreach ends the task, and integer values written to real locals
    and formals convert.
  • / and % size both operands to the wider one (§11.6.1); a narrow dividend
    used to narrow a ternary divisor and read x.
  • A two-state variable no longer stores x or z when a value with x or z bits
    is written to it from compiled code.
  • A member write through a class property whose type is a type parameter
    (class p #(type CFG = cfg_c); CFG a; ... a.x = 1;) reaches the object.
    It used to be dropped without a diagnostic, along with compound,
    nonblocking and nested writes through such a property. (PR #209 by eenky)
  • A module path or SDF delay that rounds to zero ticks is no delay: the
    change it carries happens in the same Active region as its cause. A clock
    passed through a zero-delay library cell ((posedge A => (Y:1'b1)) = (0.01, 100.0) at 1ps precision) clocked its flops after that ti...
Read more

xezim-bin 0.11.0.37217637959

Pre-release

Choose a tag to compare

Automated build of xezim-bin 0.11.0.37217637959.

Input changes since last release

  • xezim: 0.11.0 -> 0.11.0

xezim-bin 0.11.0

Choose a tag to compare

@github-actions github-actions released this 28 Sep 14:45

Automated build of xezim-bin 0.11.0.

Upstream: https://github.com/aionhw/xezim/releases/tag/0.11.0

Upstream changes

0.11.0 — code coverage, reference-parity fixes, faster UVM (September 2026)

Correctness

  • UVM: a blocking task called on a function result
    (pool.get("x").wait_trigger()) suspends the caller;
    iface_array[i].handle = new constructs the object; $typename of class
    handles, this and class typedefs prints class [pkg::]name #(params);
    std::randomize(obj.member) with {...} works; queue and dynamic-array
    locals of class methods are per call; 2-state class properties and
    struct members drop X/Z on assignment (UVM register reads of a status
    field returned X); inline constraints tying rand sub-objects together
    are solved jointly; parked wait(cond) statements re-check only when a
    name they read changes; SIGTERM and Ctrl-C end a run stuck in a
    constraint solve within 5 s.
  • The --features jit build compiles again.
  • Functional coverage: covergroups work in instantiated modules,
    interfaces, packages, file scope, multi-top designs and classes declared
    in modules (each module instance gets its own covergroup, named u0.cg
    in xezim_cov.json). Cross bodies support binsof, intersect, !,
    &&, ||, with and cross ignore_bins/illegal_bins; bins x[N],
    transition sets, lists and repetitions work; option.at_least applies to
    automatic and cross bins; @(clk iff en) and named-event sampling work;
    cg_type::get_coverage(), (covered, total), start()/stop() and
    cg.option.<name> reads are supported; illegal_bins hits are errors
    (counted by --error-exit); unlabeled coverpoints are named after their
    variable; cover sequence counts every match; and assertion entries in
    xezim_cov.json carry file and line. Coverage numbers match the
    reference simulator. See docs/coverage-guide.md.
  • UVM examples that hung now finish: a clock generator on an interface
    member (BUS.clk) toggles its own signal; a non-root module drives
    members of its own interface array (assign INT[0].irq = ...); class
    handles in child instances start as null; semaphore s = new(N) as a
    class member gets N keys; new through a typedef of a parameterized
    class builds that specialization (UVM transaction event pools);
    a redeclared base-class property keeps its own initializer; fixed-size
    arrays declared in class methods are separate per call; a class
    property takes precedence over a same-named module signal; and
    randomize() with {} constraints on members of nested rand objects
    (register-model fields) are solved.
  • sv-tests: 98.9% pass (from 97.6%). Strict checks reject malformed UDP
    table rows, duplicate non-ANSI subroutine port declarations, constructor
    body port declarations, end labels on unnamed blocks, #([7:0] A) without
    parameter, for (var [7:0] i ...), void' of a non-call, mixed
    positional and named connections, inout port defaults, generate loops
    without a genvar, self and generate-local defparam targets, and more;
    non-ANSI port expressions (.b(a[2:1]), {a, b}) are supported, and a
    ranged non-ANSI subroutine port redeclared as a reg is one port.
  • obj.randomize() with {...} binds names in the object first and then in
    the calling scope (§18.7): caller locals, inherited members, array and
    queue elements, handle members and local:: names now work, and a
    caller local no longer hides an object member. A receiver-less
    randomize() with {...} in a class method applies its inline block.
  • Randomization semantics follow the reference simulator: dist weights
    hold in coupled constraint sets (:= weighs every declared value, :/
    the whole item), solve a before b picks a uniformly, randomize(a, b) makes exactly the named members random (even non-rand ones), and
    an inside {[hi:lo]} range with the bounds reversed is empty.
  • Processes waiting on a net driven by a continuous assignment (assign CLK2 = PCLK;) resume after those waiting on its source, and waiters on
    an interface's clock port after both, as in the reference simulator.
    Testbenches that race on this order (the uart UVM example's modem tests)
    now agree with it.
  • %m and the "Scope:" line of $info/$warning/$error name the
    declaring scope (pk.f, pk.C.show, tb.u.E.show); generate blocks,
    named always blocks and labelled assertions are scopes. Auto-detected
    tops run in source order. A class and an interface may share a name,
    a blocking randcase branch suspends its process, and package-scope
    initializers may call $sformatf.
  • Absolute hierarchical writes (tb.u.sig = v) inside tasks, functions
    and class methods take effect; a callee's local declaration no longer
    changes a same-named variable's type in the caller (a signed int read
    back through inout printed unsigned); arithmetic wider than 128 bits
    keeps every bit; a forked package task runs as its own process;
    s.h = new on a struct's class-handle member constructs it; defparam
    paths resolve upward; a bare name in a class method must be visible from
    that class (UVM 1.2's removed global factory is rejected, as the
    reference simulator does).
  • sv-tests: 97.7% pass (from 94.8%). New legality checks reject what the
    LRM forbids and the reference simulator rejects: enum, unpacked-array
    and class-handle assignment compatibility, subroutine argument binding,
    constant expressions in ranges/parameters/part-selects, automatic
    variables in NBAs and procedural assigns, enum base types, packed struct
    members, net output ports, replication counts and casting sizes, gate
    terminal counts, package exports and scoped names, and parameter
    overrides. Parser: min:typ:max delays, and #6 (q, a, b), net
    declaration delays after the data type, nameless UDP instances,
    this.super.x, and begin_keywords "1364-2001-noconfig".
  • UVM 1800.2 (2020.3) DPI: uvm_re_comp/uvm_re_exec/uvm_re_compexec/
    uvm_re_deglobbed follow UVM's C code, and uvm_hdl_signal_size and
    the uvm_polling_* value-change API are built in. UVM testbenches
    compiled without UVM_NO_DPI used to abort at time 0 on unresolved
    regex symbols.
  • An inout or output formal passes a virtual-interface handle back to
    its caller even when the actual was null on entry (uvm_resource_db:: read_by_name returned nothing), and a formal no longer leaks into a
    same-named class property.
  • An unconnected 2-state output port of an interface or module starts at
    0 instead of x, so a clock driven through one toggles.
  • Deferred immediate assertions (assert #0, assert final) run their
    action blocks at the end of the time slot; a report whose process
    resumes first is dropped, and one still pending at $finish prints a
    note instead.
  • A path-delayed output also delays its first change at time 0, as the
    reference simulator does.
  • randomize() with { ... } over struct members is about 13x faster.
  • UVM tables print their rows: copying a whole element out of a
    class-property collection of unpacked structs (row = m_rows[i], queue,
    dynamic, fixed or associative) gave zeros, so the topology print and
    sprint() tables were blank. Such elements now copy, return, compare and
    print with %p correctly, and this.q[i].m reads and writes them. %s
    of a string member reached through a select no longer pads, %p of a
    string-valued call prints the string, and %0p prints it unquoted.
  • Unpacked-struct locals in initial blocks and subroutines: member writes
    through selects, packed-member fields and declaration initializers take
    effect, 2-state members start at 0, and members that are arrays of
    structs survive whole-struct assignment.
  • Time-0 activation order follows the reference simulator: depth-first
    source order through the hierarchy, bound instances after their host's
    own items (several binds into one host in reverse order), and initial
    blocks that cannot suspend run as one group.
  • Assertions: named properties and sequences declared in sub-modules and
    interfaces work in assert property, every instance of an assertion
    interface evaluates its own assertions (only the first one did), bind
    accepts interface targets by name or path, and an action block reports
    its assertion's own scope.
  • A virtual interface can be bound to a nested interface instance by
    hierarchical path (a.d, g[0].a.d), and tasks can be called through a
    generate-block path.
  • UVM's DPI-C functions are built in, so +define+UVM_NO_DPI is optional:
    regular expressions and globs for config_db, resource_db, factory
    overrides and +uvm_set_* plusargs, the command-line processor, and the
    uvm_hdl_* backdoor (read, deposit, force, release by hierarchical
    path). A --dpi-lib that defines a symbol still takes precedence.
  • A second hierarchical write such as u_sub.sig = v went into a class
    object instead of the signal once any class object existed (every UVM
    testbench). 2-state variables in instantiated modules no longer hold x/z,
    and a released net takes its drivers' value immediately.
  • Specify path delays count the declaring module's timeunit (they ran 1000x
    short in a 1ns/1ps module). All path forms are modelled (*>, polarity,
    edge-sensitive, if/ifnone, 2/3/6/12-value delay lists), the delay is
    chosen per transition and enabled path, and outputs reject pulses
    narrower than the delay. SDF IOPATH still overrides them.
  • Identifiers declared nowhere in the design are an error inside task,
    function, class-method, package, interface and program bodies, as they
    already were elsewhere.
  • Untyped parameters take the width and signedness of their initializer
    (localparam C = {8'h1, 8'h2} is 16 bits, {4{B}} and string literals
    keep all their bits, parameter unsigned P = 5 is unsigned). A string
    parameter prints with %s like a string variable.
  • Several tops each act as th...
Read more

xezim-bin 0.11.0.36436201398

Pre-release

Choose a tag to compare

Automated build of xezim-bin 0.11.0.36436201398.

Input changes since last release

  • xezim: added @ 0.11.0