Enum FuncUnit 

pub enum FuncUnit {
    DivS,
    ModS,
    FloorDivS,
    Pow,
    MulHiU,
    ApproxEqF,
    FAddF,
    FSubF,
    FMulF,
    FDivF,
    FSqrtF,
    FFloorF,
    MulOvfS,
    IntToF,
    FLtF,
    FGtF,
    FLeF,
    FGeF,
    FEqF,
    FNeF,
    PopCount,
}

A SEQUENTIAL functional unit — signed division and remainder. Unlike an AluOp, division is NOT a combinational tile: on silicon it is the multi-cycle shared_divider (already proven ≡ the VM by rtl.rs::the_signed_divider_is_proven_correct_by_our_sat), issued as a functional unit. Keeping it a distinct fabric cell lets the emitter wire that sequential unit rather than synthesize a giant combinational divider. Semantics mirror the soft-core’s shared_divider exactly, INCLUDING the divide-by-zero trap (b == 0 → 0).

Variants

DivS

Truncated signed quotient (Op::Div / Op::ExactDiv, a / b rounding toward zero).

ModS

Signed remainder taking the dividend’s sign (Op::Mod, a % b).

FloorDivS

Floor division (Op::FloorDiv, a // b rounding toward negative infinity).

Pow

Exponentiation (Op::Pow, a ** b) — a SEQUENTIAL multiplier (b multiplies) at the RTL level; the eval is the closed-form wrapping power. The VM promotes to bigint on overflow, so a fabric witness keeps a**b inside i64 (a small const exponent over the bounded fuzz range).

MulHiU

UNSIGNED high-half multiply (a·b) >> 64 (both operands as u64) — the reciprocal step of Op::MagicDivU’s magic division. On silicon it is the high word of the 64×64 multiplier; the eval takes the top 64 bits of the 128-bit unsigned product. No divider trap applies (it is a multiply).

ApproxEqF

APPROXIMATE equality (Op::ApproxEq, a is approximately b) over NUMERIC operands: both converted to f64, compared by the relative+absolute tolerance logos_approx_eq. Yields 0/1. (Float-typed operands need the float lane; the fabric refuses them at the Constant::Float load, so only the numeric-int case reaches here.) No divider trap — it is a comparison.

FAddF

The FLOAT LANE — IEEE-754 f64 operating on the bit-pattern each operand carries (f64::from_bits). Binary FAddF/FSubF/FMulF/FDivF return the result’s bits; unary FSqrtF returns bits; FFloorF returns the floored value as an Int (the float→int bridge, matching the floor builtin). No divider trap (float /0.0 is ±inf, not the integer trap).

FSubF

FMulF

FDivF

FSqrtF

FFloorF

MulOvfS

Signed 128-bit MULTIPLY OVERFLOW flag: 1 iff (a as i128) * (b as i128) does NOT fit i64 (the BigIntWide lane’s “did this product promote to a BigInt?” test — the VM’s Value::mul returns an Int when it fits and a BigInt when it does not). A comparison, so no divider trap.

IntToF

INT→FLOAT promotion: reinterpret the operand as a signed i64 value and return the bit pattern of its f64 widening ((a as f64).to_bits()). This is the fabric’s static realization of the VM’s dynamic Int ∘ Float → Float coercion (arith::multiply etc. do *a as f64 when one side is a Float): when a float op has an integer operand, the fabric promotes that operand through this unit first so the float functional unit sees two genuine f64 bit patterns. Unary (b ignored); no divider trap.

FLtF

FLOAT COMPARISONS over two f64 bit patterns, yielding the 0/1 predicate the terminator / a Select consumes. A genuine IEEE-754 compare (f64::from_bits(a) < f64::from_bits(b) etc.) — NOT the integer bit-pattern ordering a plain Select would use, which is only sound for same-sign operands and silently wrong once a negative float appears. FEqF/FNeF follow IEEE equality (so NaN != NaN). No divider trap.

FGtF

FLeF

FGeF

FEqF

FNeF

PopCount

POPCOUNT (count_ones): the number of set bits in the operand read as a u64. Unary (b ignored), combinational (a bit-adder tree), yields an Int in 0..=64 — no divider trap. The static realization of the VM’s count_ones builtin / the popcount_leaf hot path.

Implementations

impl FuncUnit

pub fn eval(&self, a: i64, b: i64) -> i64

pub fn verilog(&self, a: &str, b: &str) -> String

A COMBINATIONAL-correct Verilog lowering with the b == 0 → 0 guard — semantically identical to the sequential shared_divider (whose FSM instantiation is the area refinement). 64-bit signed, so iverilog’s truncated division/remainder is bit-identical to the VM’s Int.

impl FuncUnit

pub fn eval_checked(&self, a: i64, b: i64) -> Result<i64, Divergence>

The VM’s value for this unit, or the divergence that keeps the word from being it. Operands follow the unit’s convention (integers by value, floats as f64 bit patterns); so does the result.

Trait Implementations

impl Clone for FuncUnit

fn clone(&self) -> FuncUnit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FuncUnit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FuncUnit

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for FuncUnit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for FuncUnit

fn cmp(&self, other: &FuncUnit) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for FuncUnit

fn eq(&self, other: &FuncUnit) -> 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 PartialOrd for FuncUnit

fn partial_cmp(&self, other: &FuncUnit) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for FuncUnit

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for FuncUnit

impl Eq for FuncUnit

impl StructuralPartialEq for FuncUnit