Skip to content

xezim-bin 0.11.3

Latest

Choose a tag to compare

@github-actions github-actions released this 24 Oct 14:33
· 1 commit to main since this release

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 reaches a shift's left operand before extension
    and evaluation in compiled and interpreted execution. Self-determined
    boundaries and function side effects are preserved (§11.8.2, §11.4.10).
    (#384, reported by akashlevy)

  • Concurrent assertions and covers observe clock edges at time zero and
    four-state clock transitions, using Preponed samples (§16.5, §9.4.2).
    (#385, reported by akashlevy)

  • Assertion action blocks preserve generated scope and keep their local
    declarations separate from module variables (§16.14.1, §23.9, §27.4).
    (#386, reported by akashlevy)

  • Returning an unpacked function-name variable no longer recurses. Dynamic
    arrays, queues and fixed arrays retain their elements across return,
    including descending fixed ranges (§13.4.1, §7.6).
    (#387, reported by Dragon-Git)

  • Queue elements created from struct-returning expressions retain their
    string and other members when passed to functions or copied. Arguments
    run once even when a struct's leaf layout is unavailable
    (§7.10.2.2, §13.4.1, §13.5.1).
    (#390, #392, contributed by Ganesh-TNL)

  • Variables declared in for headers retain their declared signedness
    across synchronous and suspended loops, including typedefs and unsigned
    initializers (§6.11.1, §11.8.1, §12.7.1).
    (#394, contributed by akashlevy)

  • Full-word concatenations preserve value and X/Z bits without overflowing
    a native shift in debug execution, including nested and wide-block
    forms (§11.4.12).

  • Negated weak sequences fail when the clock stops with an attempt still
    pending. Nested negation preserves sequence strength, and disable iff
    cancels attempts even without another clock edge (§16.12.2–3).
    (#393, reported by akashlevy)

  • Followed-by properties settle at the first successful consequent tick,
    including vacuous successes, so later matches cannot add pass actions,
    cover hits or end-of-simulation failures (§16.12.9, §16.14.8).
    (#395, reported by akashlevy)

  • Tiered string casts convert bytes without padding concatenations, including
    casts through typedefs. NUL removal and byte values agree with interpreted
    calls, and persistent methods recompile for the new conversion
    (§6.16, §6.18, §6.24.3, §11.4.12).
    (#391, reported by urbanij; #396, contributed by Ganesh-TNL)

  • Interpreted nonblocking and event-controlled assignments evaluate their
    right-hand sides at the target width, preserving carries and unary results
    (§11.6.1). (#399, reported by akashlevy; #407, contributed by akashlevy)

  • Concurrent assertion operands and local match assignments retain their
    expression context width (§11.6.1, §16.10).
    (#402, reported by akashlevy; #408, contributed by akashlevy)

  • VPI-driven clocks evaluate assertions in the edge's time slot, with fixed
    slot-entry samples and Post-NBA callbacks before assertion evaluation
    (§16.5.1, §4.4.2). (#404, reported by akashlevy; #409, contributed by akashlevy)

  • The cocotb runner honors build arguments, timescales and parameter overrides,
    including later tests and positional arguments.
    (#406, reported by akashlevy; #410, contributed by akashlevy)

  • VPI writes through unpacked-array net ports reach every alias. Variable
    connections retain their propagation timing (§23.3.3.3, §23.3.3.7).
    (#405, reported by akashlevy; #411, contributed by akashlevy)

  • Sampled-value functions use declaration defaults from before time zero,
    including deferred initializers and procedural assertions (§16.5.1, §16.9.3).
    (#403, reported by akashlevy; #412, contributed by akashlevy)

  • Select writes to static subroutine locals update their shared storage and
    preserve packed member writes (§6.21, §11.5.1).
    (#413, reported by akashlevy; #414, contributed by akashlevy)

  • Concurrent assertions sample unpacked-array elements, including large
    memories, variable indices and forced values. Out-of-range slice sampling
    clips safely at extreme indices (§16.5.1, §11.5.1).
    (#415, reported by akashlevy; #416, contributed by akashlevy)

  • Named and inline assertions sample generate-block, instance-array and
    top-rooted references and recognize hierarchical clocks (§16.5.1).
    (#417, reported by akashlevy; #418, contributed by akashlevy)

  • Package-scoped virtual interfaces accept direct declarations and typedefs,
    preserve qualified copies and equality, and retain independent bindings
    when names are imported or shadowed (§25.9, §26.2, §26.3).

  • Virtual interfaces in string-keyed associative arrays preserve their keys
    through member access and handle copies, including inherited properties
    and method-local keys (§7.8, §25.10).

  • Returned virtual interfaces support member reads, writes, task calls and
    selected nonblocking targets. Receiver calls run once, and nonblocking
    targets retain their assignment syntax (§10.4.2, §25.9).

  • Parameterized static collections retain virtual-interface element identity
    through typedefs, named type arguments, reordering and static methods
    (§8.25, §25.10).

  • Copying or returning a null virtual interface clears its previous binding.
    Explicit virtual-interface locals default to null (§25.9, Table 6-7).

  • Instance-targeted binds resolve indexed and nested generate scopes,
    including constant index expressions and explicit target lists, while
    leaving sibling instances unbound (§23.11, §27). VPI retains the host's
    source definition and bound port metadata (§37).

  • Generated module instances use signed genvars, preserving negative indices
    and terminating descending loops correctly (§27.4).

  • Virtual-interface collection copies preserve element identity. Queue edits,
    associative deletion and dynamic-array allocation use the current values,
    and absent elements read as null (§7.5–§7.10, §25.10).
    (#427, reported by Ganesh-TNL)

  • Task ref, output and inout virtual-interface arguments propagate
    rebinding and null values, preserve input isolation and retain their scope
    across suspension (§13.5, §25.9).

  • Bind targets resolve against the effective hierarchy and declaration scope,
    including relative and $root paths, instance arrays, interface hosts,
    active generate branches, type parameters and defparam overrides. Repeated
    binds retain upward module references and VPI port metadata (§23.11, §37).
    Bare target names prefer the nearest visible instance over a same-named type.
    Recompile saved designs to refresh their hierarchy metadata.

  • Interface static initializers evaluate runtime system functions in each
    elaborated instance's scope before user processes, including nested,
    generated, arrayed and bound interfaces. Already deferred initializers
    retain their once-only side effects (§6.21, §25.3).
    (#435, reported by AaronKel; #436, contributed by AaronKel)

  • Compilation-unit nets retain pull values, drive strengths, resolution and
    continuous declaration assignments, including when a module shadows a unit
    name. Explicit unit writes remain distinct from later module declarations.
    Parser source locations, interface-property parameters, directive recovery
    and constraint braces and implications are also corrected.
    (core #55–#63, contributed by AaronKel, Thomasb81 and lwflwf1)

  • User constant functions select generate branches and initialize packed
    struct fields with their full argument and result widths.
    (#460 and core #64, contributed by chenbhil)

  • Static virtual-interface comparisons and method receivers share storage
    through class typedef aliases. Collection identity coverage is retained.
    (#450 and #456, contributed by Ganesh-TNL)

  • Assertion action scopes, pending property disjunctions and sampled operands
    follow their declaring instance, end-of-simulation outcome and Preponed
    values. (#457; #419, #420 and #421, contributed by Thomasb81)

  • Hierarchy diagnostics and time-zero assertion and toggle coverage fixes
    include scope and foreign-write regression coverage.
    (#439, #440, #443 and #444, contributed by akashlevy)

  • Continuous assignment sensitivity includes unnamed generate-block reads.
    (#434, contributed by Thomasb81)

  • Source locations preserve original columns after empty and multiple macro
    expansions, and identify each invocation independently (§22.5). Added
    virtual-interface recovery and postfix-span regressions.
    (#397 and #398, reported by lwflwf1)

  • Undefined statement macro calls recover as one placeholder, preserving the
    undefined-macro diagnostic and the following statement (§22.5.1).
    (#451, reported by lwflwf1)

  • Assertion, property and sequence clocking events accept or and comma
    lists, including nested groups and per-term edge and iff conditions.
    Each qualifying event advances the assertion and its sampled history
    (§16.5, §9.4.2). Recompile saved designs.
    (#453, reported by lwflwf1)

  • The cocotb runner reloads parameters when another runner rebuilds the same
    directory. Test overrides persist while the recorded build is unchanged,
    including empty overrides. (#426, reported by akashlevy)

  • Interface-array slices retain their selected instances' parameters, signal
    widths and connections when passed to array ports or forwarded through
    another module. (#463)

  • Fixed arrays of associative arrays apply each row's declared key width and
    signedness to lookups, iteration and traversal, including class properties
    and automatic task storage. (#464, reported by chenbhil)

  • Continuous assignments and always_comb writes preserve the complete width
    of nested packed elements and sub-arrays, including packed struct elements
    wider than 32 bits (§7.4.1). (#461, contributed by chenbhil)

  • Nested implications and property if preserve vacuous successes through
    their consequents, so $assertvacuousoff suppresses their pass actions.
    Nonvacuous successes remain recorded across delayed and multiple matches
    (§16.14.8, §20.12). (#445, reported by akashlevy)

  • Static virtual interfaces retain their specialization through qualified,
    typedef and object-member reads, inheritance, copies, null assignments and
    output writeback. Nested local bindings restore the enclosing interface
    after function, task and loop scopes end (§6.21, §8.26, §25.9).
    (#431, #433; #465 and #466 contributed by Ganesh-TNL)

  • Virtual-interface formals preserve the bindings of call and conditional
    arguments without repeating getter calls or leaking their bindings into
    scalar results. Output formals start null and copy that default back when
    left unassigned (§13.5.2, §25.9).

  • Hierarchical references through interface ports resolve to the connected
    interface instance, including modports, nested connections and generated
    instances. Reads, writes, waits, events and subroutine calls share that
    instance's storage (§23.8, §25.3). Recompile saved designs to refresh their
    interface-port connections.

  • Unpacked parameter arrays preserve declared bounds, element types and
    nested selections across package imports and hierarchical reads. Instance
    body overrides and array-dependent constants use the selected values
    (§6.20.2, §26.3). (#425, reported by Ganesh-TNL;
    #467 and companion core changes contributed by Ganesh-TNL)

  • Assertions and sampled-value functions continue to tick when their clock
    is reached through an interface port from a nested scope (§16.9.3, §23.8).

  • foreach walks fixed outer dimensions and each inner collection in
    declaration order, including descending bounds, inherited properties and
    hierarchical module arrays (§12.7.3). (#492, contributed by chenbhil)

  • Assertion actions read Preponed samples even when the property does not
    read the operand. Omitted virtual-interface arguments bind their defaults
    once in the declaration scope and preserve input/output identity (§16.9.3,
    §13.5.3). (#468 and #469, reported by akashlevy;
    #493 contributed by Thomasb81)

  • Assertion until, s_until and iff evaluate property operands and pending
    obligations, with strong end-of-simulation failure and Boolean X/Z truth
    handling (§16.12.8, §16.12.12). Pure constraints in concrete classes and
    parameter initializers that read specify parameters receive scoped
    diagnostics (§18.5.2, §6.20.5). Recompile saved designs to refresh their
    declaration metadata. (#493 and core #81, contributed by Thomasb81)

  • Compilation-unit constant functions are available to program and interface
    constants, including parameter headers (§13.4.3).
    (#488, reported by Dragon-Git)

  • Body type parameters retain widths, aliases, signing and class
    specializations. Module instances bind their own type overrides (§6.20.3,
    §8.3). (#498, reported by Dragon-Git)

  • Class instance and static property assignments take the declared signing
    even when the right-hand side already has the destination width. Hidden
    base properties use their own declarations and type bindings (§10.7, §8.14).
    (#499, reported by akashlevy)

  • Procedural bitwise &, |, ^ and ~^ results are signed when both
    operands are signed, preserving arithmetic and comparison behavior
    (§11.8.1). (#500, reported by akashlevy)

  • Arithmetic right shifts replicate X and Z sign bits in narrow values and
    retain the left operand's signing for unknown amounts and overshifts
    (§11.4.10).

  • Class parameter and localparam arrays preserve specialization bindings,
    element types, declared index order and assignment-pattern keys across
    class, object and method access. Recompile saved designs to refresh their
    array declaration metadata
    (§6.20.2, §8.25, §10.9.1).
    (#423, #503 and xezim-core#82, reported and contributed by Ganesh-TNL)

  • Deferred static initializers run once in each elaborated instance,
    including bound instances, generated scopes and instance arrays (§6.21).
    (#494 and #504, reported and contributed by Ganesh-TNL)

  • Class fields initialize once in declaration order after the base constructor,
    using their declared assignment types and lexical scope. Dynamic-array and
    class-typed field constructors retain their sizes and type bindings (§8.7).
    (#496 and #505, reported and contributed by Ganesh-TNL)

  • Hierarchical class-member access follows nested object handles and updates
    selected bits in instance or shared static storage. Same-named observer
    variables cannot redirect hierarchical struct accesses (§8.4, §11.5.1, §23.7).
    (#497 and #506, reported and contributed by Ganesh-TNL)

  • Unsigned expression types reach context-determined operands before nested
    division, modulus and widening are evaluated (§11.8.1/§11.8.2). Compiled
    expressions also recognize unbased fill literals as unsigned. Signed array
    elements and increment/decrement results retain their declared types
    (#501, reported by akashlevy).

  • Packed selects in parameterized child instances use each instance's
    elaborated dimensions, including typedef element widths and hierarchical
    reads (§7.4.1/§23.10; #507, contributed by chenbhil).

  • An exponent keeps its own signedness and width when a surrounding
    expression is unsigned (§11.6.1). Continuous and procedural results agree
    (#502, contributed by akashlevy).

  • Enum casts retain their declaring type through package and class names,
    including same-named classes in different packages (§6.19.3). Assigning a
    cast of a different enum is diagnosed (#511, contributed by Thomasb81).

  • Assertion or, and, iff and until preserve recursive nonvacuity
    (§16.14.8). Completed until ticks are folded so long attempts retain only
    pending evaluations (#512, contributed by Thomasb81).

  • $sampled in assertion actions reads unpacked-array cells and variable
    indices from the same sampled edge (§16.5.1), including indices changed by
    an NBA (#514, contributed by Thomasb81).

  • Whole references to class and package array constants retain specialized
    bounds, query direction and declared element order when copied (§7.6,
    §20.7), including automatic destinations (#516, contributed by Ganesh-TNL).

  • Static initializers that depend on deferred values run in declaration
    order, with function calls executed once (§6.21). Package ownership and
    dependencies in casts, slices and replications are preserved (#517,
    contributed by Ganesh-TNL).

  • Failed std::randomize calls restore scalar values, array elements and
    dynamic collection sizes, including early unsatisfiable size constraints
    (§18.12). Static subroutine locals participate in joint constraints
    (#518 and #520, contributed by Ganesh-TNL).

  • Array queries in procedural packed ranges use the current instance or
    shadowing local array (§20.7), including generated scopes and static tasks.
    Width lookup visits only queried arrays (#524, contributed by davekeeshan).

  • Forwarded packed-struct parameters retain their field layout before later
    header localparams are evaluated (§6.20, §23.10), including type bindings
    and defparam overrides (#525 and xezim-core #85, contributed by davekeeshan).

  • Constant nested member selects of packed structs in unpacked parameter
    arrays retain their values and $bits widths (§7.2.2), including qualified
    package arrays and compilation-unit typedefs (xezim-core #83, contributed
    by davekeeshan). Saved compiled designs affected by this constant-folding
    bug, the struct-parameter override bug or the static-initializer bug above
    require recompilation.

  • Class methods declared inside modules call tasks in the object's declaring
    instance (§23.8), including blocking calls through sibling and descendant
    instances. Package events keep their own identity through scoped and imported
    names, aliases and same-named declarations (§15.5, §26.3), including triggers
    from package tasks (#526, contributed by aionhw). Saved compiled designs
    affected by package event name collisions require recompilation.

  • Package typedef aliases and imports retain collection dimensions and
    packed element widths (§6.18, §26.3), including queues inside associative
    arrays of structs and same-named scalar aliases. This completes the
    xezim-core #83 namespace follow-up and preserves the #323 case reported
    by Ganesh-TNL.

Performance

  • Dense case statements with four to seven labels use jump tables, and
    comparison and constant-operand fusion recognizes temporaries reused by
    later case arms while preserving values still read on another control-flow
    path. Jump-table targets are relocated when NBA-only edge blocks merge,
    preserving that optimization for dense cases (§12.5).

  • Constant equality comparisons feeding a branch execute as one bytecode
    instruction when their result is otherwise unused, preserving X/Z semantics
    and native execution support (§11.4.5, §12.4).

  • Repeated named-event triggers reuse resolved signal targets and dense
    trigger timestamps, reducing name allocation and lookup work while retaining
    event aliasing and scheduling behavior (§15.5).

  • Constant equality branches also execute as one instruction in the two-state
    paths, preserving comparison results, branch targets and X/Z fallback.

  • Event-reference checks borrow ordinary names and alias targets, reducing
    temporary string allocation during procedural assignments.

  • Class-heavy simulations share suspended process frames, reuse object
    initialization templates, and avoid unnecessary interpreter lookups.
    An explicit XEZIM_METHOD_TIER also attempts compilation on a later call
    after enough interpreted loop iterations, including foreach; default
    admission continues to use call counts. (#326, contributed by Thomasb81)

  • The integrated correctness fixes use 1.18% more host instructions on AXI4
    and 0.004% more on C906 CoreMark than the previous main revision
    (5cd31ee5). Outputs match, and C906 guest cycles are unchanged. These
    measurements cover two interleaved AXI4 pairs and one C906 pair with one
    CoreMark iteration; they do not establish a general performance trend.

Command line

  • --tee <file> copies stdout/stderr and DPI/VPI output to a transcript while
    retaining console output. -vcd and -vcd dumpon enable source-driven VCD
    dumping like --wave. (#347, reported by akashlevy)

Maintenance

  • Core CI runs the parser crate's unit, integration and documentation tests,
    and verifies its minimum supported Rust version explicitly.
    (#455, reported by lwflwf1)

  • Expanded regression coverage for default-valued array arguments and nested
    associative collections, including repeated calls and queue element isolation.
    (#332 and #333, contributed by Thomasb81)

  • Rust warning cleanup preserves optional native execution and successful
    two-state dynamic operations. (#334, contributed by Thomasb81)

  • Shortened simulation windows and optimized dependency test builds reduce
    regression runtime. Coverage analysis stops on failed or unprofiled tests.
    (#458, contributed by Thomasb81)

Validation

  • The release passes 5,412 default debug tests in CI, with one existing
    ignored test, plus two JIT smoke tests. Core and parser CI pass 98 and
    142 tests respectively.
    The 32 DPI tests pass on Linux's nested-scheduler fallback and on macOS
    with both fibers and the fallback. Both repositories pass their minimum
    supported Rust version checks.
  • Local release checks pass 4,830 related simulator tests, 98 core tests and
    142 parser tests. Production-build checks pass 211 saved-design and cache
    checks across 24 fixtures, six AVIP workloads, and C906 hello with output
    identical to the saved reference. The C906 CoreMark comparison also
    preserves the full program output and 295,294 guest cycles.
  • Fresh 0.11.3 measurements cover C906 CoreMark, C910 memcpy with 200
    iterations and five AXI4 runs. C910 completes the 1,024-byte copy in 216
    guest CPU cycles. The README reports the measured elapsed times and
    distinguishes the historical reference timings from the new xezim runs.