cheap-masm-equivalents

name	cheap-masm-equivalents
description	Use when writing or reviewing MASM hot paths — prefer the cheaper equivalent instruction: `neq.0` over `gt.0` for non-zero checks, `cdrop` over an `if/else` selecting between two values, `dup.N` over `loc_load` for a value still on the stack, `eqw` over element-wise word comparison, `u32gt`/`u32lt` over generic `gt`/`lt` on known-u32 operands.

Prefer Cheap MASM Equivalents

Rule

Several MASM idioms have a cheap and an expensive form. Use the cheap one when both produce the same result on the inputs the procedure can see:

• Non-zero check: neq.0 (3 cycles) over gt.0 (16 cycles).
• Selecting between two values on a flag: cdrop over an if.true ... else ... end branch with the same effect.
• Re-fetch a recently-pushed value: dup.N over loc_load.N when the value is still on the stack.
• Whole-word equality: eqw over element-wise comparisons.
• u32-known operands: u32gt/u32lt over generic gt/lt.

Don't apply the cheap form when the operands violate its precondition (e.g. u32gt on a value that might exceed u32::MAX).

Why

MASM cycle costs are not uniform — gt.0 does signed-comparison work that neq.0 skips, so a hot path using the expensive form pays for it on every call. The swaps are semantically equivalent under their preconditions, so the saving is free.

Examples

# Good
push.0 neq          # non-zero check, 3 cycles
# or simply
neq.0

# Bad
push.0 gt           # same answer, 16 cycles

# Good: cdrop for ternary selection
# stack: [b, a, cond]
cdrop
# stack: [a if cond else b]

# Bad: branchy equivalent
if.true
    drop      # drop b, keep a
else
    swap drop # drop a, keep b
end

---

Source: 0xMiden/protocol — distributed by TomeVault.