Enum Cond 

pub enum Cond {
    Lt,
    Gt,
    Le,
    Ge,
    Eq,
    Ne,
    AeU,
    AU,
    BeU,
    BU,
    ParityEven,
    ParityOdd,
    Overflow,
}

An integer condition, mapping to an x86 condition code. The first six are SIGNED; Cond::AeU is the one UNSIGNED code the array bounds check needs (jae — “above or equal”, unsigned >=), used so a 1-based index whose idx - 1 wraps negative (e.g. index 0) trips the OOB exit, matching the stencil’s (im1 as u64) >= (len as u64) guard.

Variants

Lt

< (signed less): cc=0xC.

Gt

> (signed greater): cc=0xF.

Le

<= (signed less-or-equal): cc=0xE.

Ge

>= (signed greater-or-equal): cc=0xD.

Eq

==: cc=0x4.

Ne

!=: cc=0x5.

AeU

>= UNSIGNED (above or equal): cc=0x3 (jae/jnc). The array bounds-check uses this to fold the lower (im1 < 0) and upper (im1 >= len) out-of-bounds cases into ONE unsigned comparison.

AU

> UNSIGNED (above): cc=0x7 (ja). After ucomisd, seta is the strict ordered-greater test (CF=0 && ZF=0) — NaN (ZF=1) folds to FALSE, the float >/< (with swapped operands) primitive.

BeU

UNSIGNED below-or-equal: cc=0x6 (jbe). The NEGATION of AU (CF=1 || ZF=1) — the “comparison FALSE” branch for a float >/< BranchF, where NaN (ZF=1) must TAKE the false branch.

BU

UNSIGNED below: cc=0x2 (jb). After ucomisd, the strict ordered-less primitive (CF=1); NaN folds to FALSE.

ParityEven

PARITY EVEN (jp/jpe): cc=0xA. After ucomisd, PF=1 ⟺ the operands were UNORDERED (a NaN). The DivF zero-divisor guard uses this to skip the side-exit on a NaN divisor (NaN is not 0.0).

ParityOdd

PARITY ODD (jnp/jpo): cc=0xB. After ucomisd, PF=0 ⟺ ORDERED — the second half of the IEEE == test (sete && setnp), so a NaN compare yields false exactly like the reference a == b.

Overflow

OVERFLOW (jo): cc=0x0. OF=1 after a signed add/sub/imul — the integer-overflow side-exit (jo deopt) for exact arithmetic: on overflow the native tier deopts so the exact VM recomputes (and promotes to BigInt).

Trait Implementations

impl Clone for Cond

fn clone(&self) -> Cond

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Cond

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Cond

fn eq(&self, other: &Cond) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Cond

impl Eq for Cond

impl StructuralPartialEq for Cond