feat: introduce new ir optimizations

.gitignore

@@ -22,6 +22,7 @@ docs/.ub_cache/
 **/*.so
 **/*.dylib
 **/*.wasm
+**/*.wasm.rs
 
 # Test artifacts
 *.profraw

crates/herkos-runtime/src/lib.rs

@@ -26,7 +26,8 @@ mod ops;
 pub use ops::{
     i32_div_s, i32_div_u, i32_rem_s, i32_rem_u, i32_trunc_f32_s, i32_trunc_f32_u, i32_trunc_f64_s,
     i32_trunc_f64_u, i64_div_s, i64_div_u, i64_rem_s, i64_rem_u, i64_trunc_f32_s, i64_trunc_f32_u,
-    i64_trunc_f64_s, i64_trunc_f64_u,
+    i64_trunc_f64_s, i64_trunc_f64_u, wasm_max_f32, wasm_max_f64, wasm_min_f32, wasm_min_f64,
+    wasm_nearest_f32, wasm_nearest_f64,
 };
 
 /// Wasm execution errors — no panics, no unwinding.

crates/herkos-runtime/src/ops.rs

@@ -194,6 +194,147 @@ pub fn i64_rem_u(lhs: i64, rhs: i64) -> WasmResult<i64> {
         .ok_or(WasmTrap::DivisionByZero)
 }
 
+// ── Wasm float min/max/nearest ────────────────────────────────────────────────
+
+/// Wasm `f32.min`: propagates NaN (unlike Rust's `f32::min` which ignores it).
+/// Also preserves the Wasm rule `min(-0.0, +0.0) = -0.0`.
+pub fn wasm_min_f32(a: f32, b: f32) -> f32 {
+    if a.is_nan() || b.is_nan() {
+        return f32::NAN;
+    }
+    if a == 0.0 && b == 0.0 {
+        return if a.is_sign_negative() { a } else { b };
+    }
+    if a <= b {
+        a
+    } else {
+        b
+    }
+}
+
+/// Wasm `f32.max`: propagates NaN. `max(-0.0, +0.0) = +0.0`.
+pub fn wasm_max_f32(a: f32, b: f32) -> f32 {
+    if a.is_nan() || b.is_nan() {
+        return f32::NAN;
+    }
+    if a == 0.0 && b == 0.0 {
+        return if a.is_sign_positive() { a } else { b };
+    }
+    if a >= b {
+        a
+    } else {
+        b
+    }
+}
+
+/// Wasm `f64.min`: propagates NaN. `min(-0.0, +0.0) = -0.0`.
+pub fn wasm_min_f64(a: f64, b: f64) -> f64 {
+    if a.is_nan() || b.is_nan() {
+        return f64::NAN;
+    }
+    if a == 0.0 && b == 0.0 {
+        return if a.is_sign_negative() { a } else { b };
+    }
+    if a <= b {
+        a
+    } else {
+        b
+    }
+}
+
+/// Wasm `f64.max`: propagates NaN. `max(-0.0, +0.0) = +0.0`.
+pub fn wasm_max_f64(a: f64, b: f64) -> f64 {
+    if a.is_nan() || b.is_nan() {
+        return f64::NAN;
+    }
+    if a == 0.0 && b == 0.0 {
+        return if a.is_sign_positive() { a } else { b };
+    }
+    if a >= b {
+        a
+    } else {
+        b
+    }
+}
+
+/// Wasm `f32.nearest` — round to nearest even (banker's rounding).
+///
+/// Uses `as i32` for truncation-toward-zero (safe since we guard against values >= 2^23,
+/// which have no fractional bits). Avoids `f32::round`/`f32::trunc`
+/// which are not available in `no_std` without `libm`.
+pub fn wasm_nearest_f32(v: f32) -> f32 {
+    if v.is_nan() || v.is_infinite() || v == 0.0 {
+        return v;
+    }
+    // Floats >= 2^23 have no fractional bits — already an integer.
+    const NO_FRAC: f32 = 8_388_608.0; // 2^23
+    if v >= NO_FRAC || v <= -NO_FRAC {
+        return v;
+    }
+    let trunc_i = v as i32; // truncates toward zero; safe since |v| < 2^23
+    let trunc_f = trunc_i as f32;
+    let frac = v - trunc_f; // in (-1.0, 1.0), same sign as v
+    if frac > 0.5 {
+        (trunc_i + 1) as f32
+    } else if frac < -0.5 {
+        (trunc_i - 1) as f32
+    } else if frac == 0.5 {
+        // Tie: round to even (trunc_i is the floor for positive v).
+        if trunc_i % 2 == 0 {
+            trunc_f
+        } else {
+            (trunc_i + 1) as f32
+        }
+    } else if frac == -0.5 {
+        // Tie: round to even. copysign preserves -0.0 when trunc_i == 0.
+        if trunc_i % 2 == 0 {
+            f32::copysign(trunc_f, v)
+        } else {
+            (trunc_i - 1) as f32
+        }
+    } else {
+        trunc_f
+    }
+}
+
+/// Wasm `f64.nearest` — round to nearest even (banker's rounding).
+///
+/// Uses `as i64` for truncation-toward-zero (safe since we guard against values >= 2^52,
+/// which have no fractional bits). Avoids `f64::round`/`f64::trunc`
+/// which are not available in `no_std` without `libm`.
+pub fn wasm_nearest_f64(v: f64) -> f64 {
+    if v.is_nan() || v.is_infinite() || v == 0.0 {
+        return v;
+    }
+    // Floats >= 2^52 have no fractional bits — already an integer.
+    const NO_FRAC: f64 = 4_503_599_627_370_496.0; // 2^52
+    if v >= NO_FRAC || v <= -NO_FRAC {
+        return v;
+    }
+    let trunc_i = v as i64; // truncates toward zero; safe since |v| < 2^52
+    let trunc_f = trunc_i as f64;
+    let frac = v - trunc_f;
+    if frac > 0.5 {
+        (trunc_i + 1) as f64
+    } else if frac < -0.5 {
+        (trunc_i - 1) as f64
+    } else if frac == 0.5 {
+        if trunc_i % 2 == 0 {
+            trunc_f
+        } else {
+            (trunc_i + 1) as f64
+        }
+    } else if frac == -0.5 {
+        if trunc_i % 2 == 0 {
+            f64::copysign(trunc_f, v)
+        } else {
+            (trunc_i - 1) as f64
+        }
+    } else {
+        trunc_f
+    }
+}
+
 // ── Tests ─────────────────────────────────────────────────────────────────────
 
 #[cfg(test)]

crates/herkos/Cargo.toml

@@ -16,6 +16,7 @@ wasmparser = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
 heck = { workspace = true }
+herkos-runtime = { path = "../herkos-runtime", version = "0.1.1" }
 
 [dev-dependencies]
 wat = { workspace = true }

crates/herkos/src/backend/mod.rs

@@ -106,6 +106,19 @@ pub trait Backend {
         if_false_idx: usize,
     ) -> String;
 
+    /// Emit Rust code for a conditional branch with an inlined comparison.
+    ///
+    /// Instead of `if condition != 0`, emits the comparison directly:
+    /// `if lhs >= rhs { ... } else { ... }`.
+    fn emit_branch_cmp_to_index(
+        &self,
+        op: BinOp,
+        lhs: VarId,
+        rhs: VarId,
+        if_true_idx: usize,
+        if_false_idx: usize,
+    ) -> String;
+
     /// Emit Rust code for multi-way branch (br_table) using block indices.
     fn emit_branch_table_to_index(
         &self,

crates/herkos/src/backend/safe.rs

@@ -564,6 +564,21 @@ impl Backend for SafeBackend {
         )
     }
 
+    fn emit_branch_cmp_to_index(
+        &self,
+        op: BinOp,
+        lhs: VarId,
+        rhs: VarId,
+        if_true_idx: usize,
+        if_false_idx: usize,
+    ) -> String {
+        let cmp_expr = format_cmp_expr(op, lhs, rhs);
+        format!(
+            "                if {cmp_expr} {{\n                    __current_block = Block::B{};\n                }} else {{\n                    __current_block = Block::B{};\n                }}\n                continue;",
+            if_true_idx, if_false_idx
+        )
+    }
+
     fn emit_branch_table_to_index(
         &self,
         index: VarId,
@@ -597,3 +612,42 @@ impl Backend for SafeBackend {
         code
     }
 }
+
+/// Format a comparison expression for use in branch conditions.
+fn format_cmp_expr(op: BinOp, lhs: VarId, rhs: VarId) -> String {
+    match op {
+        // Signed i32 comparisons
+        BinOp::I32Eq => format!("{lhs} == {rhs}"),
+        BinOp::I32Ne => format!("{lhs} != {rhs}"),
+        BinOp::I32LtS => format!("{lhs} < {rhs}"),
+        BinOp::I32GtS => format!("{lhs} > {rhs}"),
+        BinOp::I32LeS => format!("{lhs} <= {rhs}"),
+        BinOp::I32GeS => format!("{lhs} >= {rhs}"),
+        // Unsigned i32 comparisons
+        BinOp::I32LtU => format!("({lhs} as u32) < ({rhs} as u32)"),
+        BinOp::I32GtU => format!("({lhs} as u32) > ({rhs} as u32)"),
+        BinOp::I32LeU => format!("({lhs} as u32) <= ({rhs} as u32)"),
+        BinOp::I32GeU => format!("({lhs} as u32) >= ({rhs} as u32)"),
+        // Signed i64 comparisons
+        BinOp::I64Eq => format!("{lhs} == {rhs}"),
+        BinOp::I64Ne => format!("{lhs} != {rhs}"),
+        BinOp::I64LtS => format!("{lhs} < {rhs}"),
+        BinOp::I64GtS => format!("{lhs} > {rhs}"),
+        BinOp::I64LeS => format!("{lhs} <= {rhs}"),
+        BinOp::I64GeS => format!("{lhs} >= {rhs}"),
+        // Unsigned i64 comparisons
+        BinOp::I64LtU => format!("({lhs} as u64) < ({rhs} as u64)"),
+        BinOp::I64GtU => format!("({lhs} as u64) > ({rhs} as u64)"),
+        BinOp::I64LeU => format!("({lhs} as u64) <= ({rhs} as u64)"),
+        BinOp::I64GeU => format!("({lhs} as u64) >= ({rhs} as u64)"),
+        // Float comparisons
+        BinOp::F32Eq | BinOp::F64Eq => format!("{lhs} == {rhs}"),
+        BinOp::F32Ne | BinOp::F64Ne => format!("{lhs} != {rhs}"),
+        BinOp::F32Lt | BinOp::F64Lt => format!("{lhs} < {rhs}"),
+        BinOp::F32Gt | BinOp::F64Gt => format!("{lhs} > {rhs}"),
+        BinOp::F32Le | BinOp::F64Le => format!("{lhs} <= {rhs}"),
+        BinOp::F32Ge | BinOp::F64Ge => format!("{lhs} >= {rhs}"),
+        // Non-comparison ops should never reach here
+        _ => format!("{lhs} != 0 /* unexpected non-comparison op */"),
+    }
+}

crates/herkos/src/codegen/function.rs

@@ -172,10 +172,27 @@ pub fn generate_function_with_info<B: Backend>(
     output.push_str("    loop {\n");
     output.push_str("        match __current_block {\n");
 
+    // Build global use counts for branch condition inlining.
+    let global_uses = crate::optimizer::utils::build_global_use_count(ir_func);
+
     for (idx, block) in ir_func.blocks.iter().enumerate() {
         output.push_str(&format!("            Block::B{} => {{\n", idx));
 
+        // Detect if the BranchIf condition is a single-use comparison BinOp
+        // defined in this block — if so, skip emitting it and inline into branch.
+        let inlined_cmp = detect_inlined_cmp(block, &global_uses);
+        let skip_var = inlined_cmp.as_ref().map(|_| match &block.terminator {
+            IrTerminator::BranchIf { condition, .. } => *condition,
+            _ => unreachable!(),
+        });
+
         for instr in &block.instructions {
+            // Skip the inlined comparison instruction
+            if let Some(skip) = skip_var {
+                if crate::optimizer::utils::instr_dest(instr) == Some(skip) {
+                    continue;
+                }
+            }
             let code =
                 crate::codegen::instruction::generate_instruction_with_info(backend, instr, info)?;
             output.push_str(&code);
@@ -187,6 +204,7 @@ pub fn generate_function_with_info<B: Backend>(
             &block.terminator,
             &block_id_to_index,
             ir_func.return_type,
+            inlined_cmp.as_ref(),
         );
         output.push_str(&term_code);
         output.push('\n');
@@ -290,6 +308,48 @@ fn generate_signature_with_info<B: Backend>(
     sig
 }
 
+/// Detect whether a block's `BranchIf` condition is defined by a single-use
+/// comparison `BinOp` instruction within the same block. If so, return the
+/// comparison info for inlining into the branch.
+fn detect_inlined_cmp(
+    block: &IrBlock,
+    global_uses: &std::collections::HashMap<VarId, usize>,
+) -> Option<crate::codegen::instruction::InlinedCmp> {
+    let condition = match &block.terminator {
+        IrTerminator::BranchIf { condition, .. } => *condition,
+        _ => return None,
+    };
+
+    // Condition must have exactly one use (the BranchIf itself).
+    if global_uses.get(&condition).copied().unwrap_or(0) != 1 {
+        return None;
+    }
+
+    // Find the defining instruction in this block.
+    for (i, instr) in block.instructions.iter().enumerate() {
+        if let IrInstr::BinOp { dest, op, lhs, rhs } = instr {
+            if *dest == condition && op.is_comparison() {
+                // Safety: verify no instruction after this one redefines
+                // lhs or rhs. If they do, inlining at branch-time would see
+                // the wrong operand values.
+                let operands_stable = !block.instructions[i + 1..].iter().any(|later| {
+                    let d = crate::optimizer::utils::instr_dest(later);
+                    d == Some(*lhs) || d == Some(*rhs)
+                });
+                if operands_stable {
+                    return Some(crate::codegen::instruction::InlinedCmp {
+                        op: *op,
+                        lhs: *lhs,
+                        rhs: *rhs,
+                    });
+                }
+            }
+        }
+    }
+
+    None
+}
+
 /// Check if an IR function has any import calls.
 fn has_import_calls(ir_func: &IrFunction) -> bool {
     ir_func.blocks.iter().any(|block| {