Add integer-spec compare-jump opcodes for tail-recur loops

Author: 0xhenrique

src/bytecode.rs

@@ -86,6 +86,8 @@ impl std::fmt::Debug for Op {
             Self::GE_INT => write!(f, "GeInt({}, {}, {})", self.a(), self.b(), self.c()),
             Self::JUMP_IF_LE_INT_IMM => write!(f, "JumpIfLeIntImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
             Self::JUMP_IF_GT_INT_IMM => write!(f, "JumpIfGtIntImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
+            Self::JUMP_IF_LT_INT_IMM => write!(f, "JumpIfLtIntImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
+            Self::JUMP_IF_GE_INT_IMM => write!(f, "JumpIfGeIntImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
             _ => write!(f, "Unknown(0x{:08x})", self.0),
         }
     }
@@ -171,6 +173,8 @@ impl Op {
     // Combined compare-and-jump for integers (most common loop pattern)
     pub const JUMP_IF_LE_INT_IMM: u8 = 64; // ABC: src, imm (i8), offset (i8) - jump if src <= imm
     pub const JUMP_IF_GT_INT_IMM: u8 = 65; // ABC: src, imm (i8), offset (i8) - jump if src > imm (for opposite)
+    pub const JUMP_IF_LT_INT_IMM: u8 = 66; // ABC: src, imm (i8), offset (i8) - jump if src < imm
+    pub const JUMP_IF_GE_INT_IMM: u8 = 67; // ABC: src, imm (i8), offset (i8) - jump if src >= imm    
 
     // ========== Constructors ==========
 
@@ -580,6 +584,16 @@ impl Op {
         Self::abc(Self::JUMP_IF_GT_INT_IMM, src, imm as u8, offset as u8)
     }
 
+    #[inline(always)]
+    pub const fn jump_if_lt_int_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_LT_INT_IMM, src, imm as u8, offset as u8)
+    }
+
+    #[inline(always)]
+    pub const fn jump_if_ge_int_imm(src: Reg, imm: i8, offset: i8) -> Self {
+        Self::abc(Self::JUMP_IF_GE_INT_IMM, src, imm as u8, offset as u8)
+    }
+
     // ========== Jump patching helpers ==========
 
     /// Check if this is a jump instruction (for patching)
@@ -593,6 +607,7 @@ impl Op {
             || op == Self::JUMP_IF_GT_IMM || op == Self::JUMP_IF_GE_IMM
             || op == Self::JUMP_IF_NIL || op == Self::JUMP_IF_NOT_NIL
             || op == Self::JUMP_IF_LE_INT_IMM || op == Self::JUMP_IF_GT_INT_IMM
+            || op == Self::JUMP_IF_LT_INT_IMM || op == Self::JUMP_IF_GE_INT_IMM            
     }
 
     /// Patch the offset of a jump instruction
@@ -602,7 +617,12 @@ impl Op {
         let a = self.a();
         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 {
+        if (opcode >= Self::JUMP_IF_LT && opcode <= Self::JUMP_IF_GE_IMM)
+            || opcode == Self::JUMP_IF_LE_INT_IMM
+            || opcode == Self::JUMP_IF_GT_INT_IMM
+            || opcode == Self::JUMP_IF_LT_INT_IMM
+            || opcode == Self::JUMP_IF_GE_INT_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 {
@@ -671,7 +691,8 @@ impl Chunk {
                     jump_targets[target] = true;
                 }
             } else if (opcode >= Op::JUMP_IF_LT && opcode <= Op::JUMP_IF_GE_IMM)
-                || opcode == Op::JUMP_IF_LE_INT_IMM || opcode == Op::JUMP_IF_GT_INT_IMM {
+                || opcode == Op::JUMP_IF_LE_INT_IMM || opcode == Op::JUMP_IF_GT_INT_IMM
+                || opcode == Op::JUMP_IF_LT_INT_IMM || opcode == Op::JUMP_IF_GE_INT_IMM {
                 // These use i8 offset in C byte
                 let offset = op.c() as i8 as isize;
                 let target = (i as isize + 1 + offset) as usize;
@@ -720,7 +741,8 @@ impl Chunk {
                 }
                 Op::JUMP_IF_LT_IMM | Op::JUMP_IF_LE_IMM |
                 Op::JUMP_IF_GT_IMM | Op::JUMP_IF_GE_IMM |
-                Op::JUMP_IF_LE_INT_IMM | Op::JUMP_IF_GT_INT_IMM => {
+                Op::JUMP_IF_LE_INT_IMM | Op::JUMP_IF_GT_INT_IMM |
+                Op::JUMP_IF_LT_INT_IMM | Op::JUMP_IF_GE_INT_IMM => {                    
                     ever_live |= 1u128 << op.a();
                 }
                 _ => {}
@@ -869,7 +891,8 @@ impl Chunk {
 
                 Op::JUMP_IF_LT_IMM | Op::JUMP_IF_LE_IMM |
                 Op::JUMP_IF_GT_IMM | Op::JUMP_IF_GE_IMM |
-                Op::JUMP_IF_LE_INT_IMM | Op::JUMP_IF_GT_INT_IMM => {
+                Op::JUMP_IF_LE_INT_IMM | Op::JUMP_IF_GT_INT_IMM |
+                Op::JUMP_IF_LT_INT_IMM | Op::JUMP_IF_GE_INT_IMM => {                
                     let src = op.a();
                     live |= 1u128 << src;
                 }

src/compiler.rs

@@ -540,21 +540,15 @@ impl Compiler {
         }
 
         // Parameters occupy the first registers
-        // For loop-optimized functions (self-recursive), assume numeric parameters are integers
-        // This is a technique that enables integer-specialized opcodes for common patterns
-        // like sum(n, acc) where n and acc are typically integers.
-        let is_loop_optimized = name.is_some();
+        // Note: We don't assume parameter types because:
+        // >self-recursive functions may not be tail-recursive
+        // >even tail-recursive functions might be called with different types
+        // Integer-specialized opcodes will still fire for integer literals and
+        // results of integer operations, which covers most hot paths
         for param in params {
             compiler.locals.push(param.clone());
-            // For loop-optimized functions, assume parameters are Int
-            // This enables integer-specialized opcodes in the hot loop
-            if is_loop_optimized {
-                compiler.reg_types.push(StaticType::Int);
-                compiler.param_types.push(StaticType::Int);
-            } else {
-                compiler.reg_types.push(StaticType::Unknown);
-                compiler.param_types.push(StaticType::Unknown);
-            }
+            compiler.reg_types.push(StaticType::Unknown);
+            compiler.param_types.push(StaticType::Unknown);
         }
 
         let dest = compiler.alloc_reg();
@@ -789,6 +783,9 @@ impl Compiler {
     /// - `<=` → JumpIfGt (jump if a > b)
     /// - `>`  → JumpIfLe (jump if a <= b)
     /// - `>=` → JumpIfLt (jump if a < b)
+    ///
+    /// When the left operand is known to be an integer, we use integer-specialized
+    /// opcodes that skip type checking (faster in tight loops).    
     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,
@@ -803,6 +800,10 @@ impl Compiler {
         let left = &items[1];
         let right = &items[2];
 
+        // Infer type of left operand to determine if we can use integer-specialized opcodes
+        let left_type = self.infer_type(left);
+        let use_int_opcodes = left_type == StaticType::Int;
+
         // 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 {
@@ -811,12 +812,22 @@ impl Compiler {
 
                 // 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!(),
+                let jump_pos = if use_int_opcodes {
+                    match op {
+                        "<"  => self.emit(Op::jump_if_ge_int_imm(dest, imm as i8, 0)),
+                        "<=" => self.emit(Op::jump_if_gt_int_imm(dest, imm as i8, 0)),
+                        ">"  => self.emit(Op::jump_if_le_int_imm(dest, imm as i8, 0)),
+                        ">=" => self.emit(Op::jump_if_lt_int_imm(dest, imm as i8, 0)),
+                        _ => unreachable!(),
+                    }
+                } else {
+                    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));
             }

src/vm.rs

@@ -1280,6 +1280,28 @@ impl VM {
                     }
                 }
 
+                Op::JUMP_IF_LT_INT_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 x = unsafe { v.as_int_unchecked() };
+                    if x < imm {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
+                Op::JUMP_IF_GE_INT_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 x = unsafe { v.as_int_unchecked() };
+                    if x >= imm {
+                        ip = (ip as isize + offset as isize) as usize;
+                    }
+                }
+
                 _ => {
                     return Err(format!("Unknown opcode: {}", instr.opcode()));
                 }