Register-Register: JumpIfLt(left, right, offset)

Register-Immediate: JumpIfLtImm(src, imm, offset)
Uses 8-bit signed offset (127 instructions aprox)

Author: 0xhenrique

src/bytecode.rs

@@ -60,6 +60,14 @@ impl std::fmt::Debug for Op {
             Self::LE_IMM => write!(f, "LeImm({}, {}, {})", self.a(), self.b(), self.c() as i8),
             Self::GT_IMM => write!(f, "GtImm({}, {}, {})", self.a(), self.b(), self.c() as i8),
             Self::GE_IMM => write!(f, "GeImm({}, {}, {})", self.a(), self.b(), self.c() as i8),
+            Self::JUMP_IF_LT => write!(f, "JumpIfLt({}, {}, {})", self.a(), self.b(), self.c() as i8),
+            Self::JUMP_IF_LE => write!(f, "JumpIfLe({}, {}, {})", self.a(), self.b(), self.c() as i8),
+            Self::JUMP_IF_GT => write!(f, "JumpIfGt({}, {}, {})", self.a(), self.b(), self.c() as i8),
+            Self::JUMP_IF_GE => write!(f, "JumpIfGe({}, {}, {})", self.a(), self.b(), self.c() as i8),
+            Self::JUMP_IF_LT_IMM => write!(f, "JumpIfLtImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
+            Self::JUMP_IF_LE_IMM => write!(f, "JumpIfLeImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
+            Self::JUMP_IF_GT_IMM => write!(f, "JumpIfGtImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
+            Self::JUMP_IF_GE_IMM => write!(f, "JumpIfGeImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
             _ => write!(f, "Unknown(0x{:08x})", self.0),
         }
     }
@@ -107,6 +115,15 @@ impl Op {
     pub const LE_IMM: u8 = 37;         // ABC: dest, src, imm (C is i8) - src <= imm
     pub const GT_IMM: u8 = 38;         // ABC: dest, src, imm (C is i8) - src > imm
     pub const GE_IMM: u8 = 39;         // ABC: dest, src, imm (C is i8) - src >= imm
+    // Combined compare-and-jump opcodes (saves a register + dispatch overhead)
+    pub const JUMP_IF_LT: u8 = 40;     // ABC: left, right, offset (i8) - jump if left < right
+    pub const JUMP_IF_LE: u8 = 41;     // ABC: left, right, offset (i8) - jump if left <= right
+    pub const JUMP_IF_GT: u8 = 42;     // ABC: left, right, offset (i8) - jump if left > right
+    pub const JUMP_IF_GE: u8 = 43;     // ABC: left, right, offset (i8) - jump if left >= right
+    pub const JUMP_IF_LT_IMM: u8 = 44; // ABC: src, imm (i8), offset (i8) - jump if src < imm
+    pub const JUMP_IF_LE_IMM: u8 = 45; // ABC: src, imm (i8), offset (i8) - jump if src <= imm
+    pub const JUMP_IF_GT_IMM: u8 = 46; // ABC: src, imm (i8), offset (i8) - jump if src > imm
+    pub const JUMP_IF_GE_IMM: u8 = 47; // ABC: src, imm (i8), offset (i8) - jump if src >= imm
 
     // ========== Constructors ==========
 
@@ -370,22 +387,72 @@ impl Op {
         Self::abc(Self::GE_IMM, dest, src, imm as u8)
     }
 
+    // Combined compare-and-jump (register vs register)
+    #[inline(always)]
+    pub const fn jump_if_lt(left: Reg, right: Reg, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_LT, left, right, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_le(left: Reg, right: Reg, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_LE, left, right, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_gt(left: Reg, right: Reg, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_GT, left, right, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_ge(left: Reg, right: Reg, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_GE, left, right, offset as u8)
+    }
+
+    // Combined compare-and-jump (register vs immediate)
+    #[inline(always)]
+    pub const fn jump_if_lt_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_LT_IMM, src, imm as u8, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_le_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_LE_IMM, src, imm as u8, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_gt_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_GT_IMM, src, imm as u8, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_ge_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_GE_IMM, src, imm as u8, offset as u8)
+    }
+
     // ========== Jump patching helpers ==========
 
     /// Check if this is a jump instruction (for patching)
     #[inline(always)]
     pub const fn is_jump(self) -> bool {
         let op = self.opcode();
         op == Self::JUMP || op == Self::JUMP_IF_FALSE || op == Self::JUMP_IF_TRUE
+            || op == Self::JUMP_IF_LT || op == Self::JUMP_IF_LE
+            || op == Self::JUMP_IF_GT || op == Self::JUMP_IF_GE
+            || op == Self::JUMP_IF_LT_IMM || op == Self::JUMP_IF_LE_IMM
+            || op == Self::JUMP_IF_GT_IMM || op == Self::JUMP_IF_GE_IMM
     }
 
     /// Patch the offset of a jump instruction
     #[inline(always)]
     pub fn patch_offset(&mut self, new_offset: i16) {
         let opcode = self.opcode();
         let a = self.a();
-        // Reconstruct with new offset
-        if opcode == Self::JUMP {
+        let b = self.b();
+        // Combined compare-and-jump use ABC format with C as 8-bit offset
+        if opcode >= Self::JUMP_IF_LT && opcode <= Self::JUMP_IF_GE_IMM {
+            // For these opcodes: A=left/src, B=right/imm, C=offset (i8)
+            *self = Self::abc(opcode, a, b, new_offset as i8 as u8);
+        } else if opcode == Self::JUMP {
             *self = Self::make_sbx(opcode, new_offset);
         } else {
             *self = Self::asbx(opcode, a, new_offset);

src/compiler.rs

@@ -505,12 +505,23 @@ impl Compiler {
             return Err("if expects 2 or 3 arguments".to_string());
         }
 
-        // Compile condition into dest
+        // Try to use combined compare-and-jump opcodes for comparison conditions
+        if let Some(jump_to_else) = self.try_compile_compare_jump(&args[0], dest)? {
+            // Successfully emitted a combined compare-and-jump opcode
+            return self.compile_if_branches(args, dest, tail_pos, jump_to_else);
+        }
+
+        // Fallback: compile condition into dest and use JumpIfFalse
         self.compile_expr(&args[0], dest, false)?;
 
         // Jump to else if false
         let jump_to_else = self.emit(Op::jump_if_false(dest, 0));
 
+        self.compile_if_branches(args, dest, tail_pos, jump_to_else)
+    }
+
+    /// Compile the then/else branches of an if expression
+    fn compile_if_branches(&mut self, args: &[Value], dest: Reg, tail_pos: bool, jump_to_else: usize) -> Result<(), String> {
         // Compile then branch
         self.compile_expr(&args[1], dest, tail_pos)?;
 
@@ -543,6 +554,68 @@ impl Compiler {
         Ok(())
     }
 
+    /// Try to compile a comparison condition as a combined compare-and-jump opcode.
+    /// Returns Some(jump_pos) if successful, None if condition is not a simple comparison.
+    ///
+    /// For `(if (< a b) then else)`, we need to jump to else when condition is FALSE.
+    /// So we emit the OPPOSITE comparison:
+    /// - `<`  → JumpIfGe (jump if a >= b)
+    /// - `<=` → JumpIfGt (jump if a > b)
+    /// - `>`  → JumpIfLe (jump if a <= b)
+    /// - `>=` → JumpIfLt (jump if a < b)
+    fn try_compile_compare_jump(&mut self, cond: &Value, dest: Reg) -> Result<Option<usize>, String> {
+        let items = match cond.as_list() {
+            Some(items) if items.len() == 3 => items,
+            _ => return Ok(None),
+        };
+
+        let op = match items[0].as_symbol() {
+            Some(s) if s == "<" || s == "<=" || s == ">" || s == ">=" => s,
+            _ => return Ok(None),
+        };
+
+        let left = &items[1];
+        let right = &items[2];
+
+        // Check for immediate optimization: (< x 0), (<= n 10), etc.
+        if let Some(imm) = right.as_int() {
+            if imm >= i8::MIN as i64 && imm <= i8::MAX as i64 {
+                // Compile left operand into dest
+                self.compile_expr(left, dest, false)?;
+
+                // Emit combined compare-jump with OPPOSITE comparison
+                // placeholder offset 0, will be patched later
+                let jump_pos = match op {
+                    "<"  => self.emit(Op::jump_if_ge_imm(dest, imm as i8, 0)),
+                    "<=" => self.emit(Op::jump_if_gt_imm(dest, imm as i8, 0)),
+                    ">"  => self.emit(Op::jump_if_le_imm(dest, imm as i8, 0)),
+                    ">=" => self.emit(Op::jump_if_lt_imm(dest, imm as i8, 0)),
+                    _ => unreachable!(),
+                };
+                return Ok(Some(jump_pos));
+            }
+        }
+
+        // Register-register comparison
+        // Compile left into dest
+        self.compile_expr(left, dest, false)?;
+        // Compile right into temp register
+        let right_reg = self.alloc_reg();
+        self.compile_expr(right, right_reg, false)?;
+
+        // Emit combined compare-jump with OPPOSITE comparison
+        let jump_pos = match op {
+            "<"  => self.emit(Op::jump_if_ge(dest, right_reg, 0)),
+            "<=" => self.emit(Op::jump_if_gt(dest, right_reg, 0)),
+            ">"  => self.emit(Op::jump_if_le(dest, right_reg, 0)),
+            ">=" => self.emit(Op::jump_if_lt(dest, right_reg, 0)),
+            _ => unreachable!(),
+        };
+
+        self.free_reg(); // free right_reg
+        Ok(Some(jump_pos))
+    }
+
     fn compile_def(&mut self, args: &[Value], dest: Reg) -> Result<(), String> {
         if args.len() != 2 {
             return Err("def expects exactly 2 arguments".to_string());

src/vm.rs

@@ -775,6 +775,120 @@ impl VM {
                     unsafe { *self.registers.get_unchecked_mut(base + dest as usize) = result };
                 }
 
+                // Combined compare-and-jump (register vs register)
+                Op::JUMP_IF_LT => {
+                    let left = instr.a();
+                    let right = instr.b();
+                    let offset = instr.c() as i8;
+                    let va = unsafe { self.registers.get_unchecked(base + left as usize) };
+                    let vb = unsafe { self.registers.get_unchecked(base + right as usize) };
+                    if compare_values(va, vb)? == std::cmp::Ordering::Less {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_LE => {
+                    let left = instr.a();
+                    let right = instr.b();
+                    let offset = instr.c() as i8;
+                    let va = unsafe { self.registers.get_unchecked(base + left as usize) };
+                    let vb = unsafe { self.registers.get_unchecked(base + right as usize) };
+                    if compare_values(va, vb)? != std::cmp::Ordering::Greater {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_GT => {
+                    let left = instr.a();
+                    let right = instr.b();
+                    let offset = instr.c() as i8;
+                    let va = unsafe { self.registers.get_unchecked(base + left as usize) };
+                    let vb = unsafe { self.registers.get_unchecked(base + right as usize) };
+                    if compare_values(va, vb)? == std::cmp::Ordering::Greater {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_GE => {
+                    let left = instr.a();
+                    let right = instr.b();
+                    let offset = instr.c() as i8;
+                    let va = unsafe { self.registers.get_unchecked(base + left as usize) };
+                    let vb = unsafe { self.registers.get_unchecked(base + right as usize) };
+                    if compare_values(va, vb)? != std::cmp::Ordering::Less {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                // Combined compare-and-jump (register vs immediate)
+                Op::JUMP_IF_LT_IMM => {
+                    let src = instr.a();
+                    let imm = instr.b() as i8 as i64;
+                    let offset = instr.c() as i8;
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    let should_jump = if let Some(x) = v.as_int() {
+                        x < imm
+                    } else if let Some(x) = v.as_float() {
+                        x < imm as f64
+                    } else {
+                        return Err("< expects a number".to_string());
+                    };
+                    if should_jump {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_LE_IMM => {
+                    let src = instr.a();
+                    let imm = instr.b() as i8 as i64;
+                    let offset = instr.c() as i8;
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    let should_jump = if let Some(x) = v.as_int() {
+                        x <= imm
+                    } else if let Some(x) = v.as_float() {
+                        x <= imm as f64
+                    } else {
+                        return Err("<= expects a number".to_string());
+                    };
+                    if should_jump {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_GT_IMM => {
+                    let src = instr.a();
+                    let imm = instr.b() as i8 as i64;
+                    let offset = instr.c() as i8;
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    let should_jump = if let Some(x) = v.as_int() {
+                        x > imm
+                    } else if let Some(x) = v.as_float() {
+                        x > imm as f64
+                    } else {
+                        return Err("> expects a number".to_string());
+                    };
+                    if should_jump {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_GE_IMM => {
+                    let src = instr.a();
+                    let imm = instr.b() as i8 as i64;
+                    let offset = instr.c() as i8;
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    let should_jump = if let Some(x) = v.as_int() {
+                        x >= imm
+                    } else if let Some(x) = v.as_float() {
+                        x >= imm as f64
+                    } else {
+                        return Err(">= expects a number".to_string());
+                    };
+                    if should_jump {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
                 _ => {
                     return Err(format!("Unknown opcode: {}", instr.opcode()));
                 }
@@ -1344,4 +1458,34 @@ mod tests {
         let result = vm_eval("(do (def count-down (fn (n) (if (<= n 0) 0 (+ 1 (count-down (- n 1)))))) (count-down 10))").unwrap();
         assert_eq!(result, Value::Int(10));
     }
+
+    #[test]
+    fn test_combined_compare_jump() {
+        // Test combined compare-and-jump opcodes
+        // These are generated for (if (< a b) ...) patterns
+
+        // Immediate variants
+        assert_eq!(vm_eval("(if (< 5 10) 1 2)").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(if (< 15 10) 1 2)").unwrap(), Value::Int(2));
+        assert_eq!(vm_eval("(if (<= 10 10) 1 2)").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(if (<= 11 10) 1 2)").unwrap(), Value::Int(2));
+        assert_eq!(vm_eval("(if (> 15 10) 1 2)").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(if (> 5 10) 1 2)").unwrap(), Value::Int(2));
+        assert_eq!(vm_eval("(if (>= 10 10) 1 2)").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(if (>= 9 10) 1 2)").unwrap(), Value::Int(2));
+
+        // Variable vs immediate (uses JumpIfXxxImm)
+        assert_eq!(vm_eval("(let (x 5) (if (< x 10) 1 2))").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(let (x 15) (if (< x 10) 1 2))").unwrap(), Value::Int(2));
+        assert_eq!(vm_eval("(let (n 0) (if (<= n 0) 1 2))").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(let (n 1) (if (<= n 0) 1 2))").unwrap(), Value::Int(2));
+
+        // Variable vs variable (uses JumpIfXxx)
+        assert_eq!(vm_eval("(let (a 5 b 10) (if (< a b) 1 2))").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(let (a 15 b 10) (if (< a b) 1 2))").unwrap(), Value::Int(2));
+
+        // Recursive function using combined compare-jump
+        let result = vm_eval("(do (def sum (fn (n acc) (if (<= n 0) acc (sum (- n 1) (+ acc n))))) (sum 100 0))").unwrap();
+        assert_eq!(result, Value::Int(5050));
+    }
 }