Perf(vm): Annotate error constructors with #[cold] to keep hot paths linear.

Author: dylan-sutton-chavez

compiler/src/modules/vm/mod.rs

@@ -358,15 +358,15 @@ impl<'a> VM<'a> {
                 OpCode::JumpIfFalse => {
                     let v = self.pop()?;
                     if !self.truthy(v) {
-                        if self.budget == 0 { return Err(VmErr::Budget); }
+                        if self.budget == 0 { return Err(cold_budget()); }
                         self.budget -= 1;
                         let target = op as usize;
                         if target > chunk.instructions.len() { return Err(VmErr::Runtime("jump target out of bounds".into())); }
                         ip = target;
                     }
                 }
                 OpCode::Jump => {
-                    if self.budget == 0 { return Err(VmErr::Budget); }
+                    if self.budget == 0 { return Err(cold_budget()); }
                     self.budget -= 1;
                     let target = op as usize;
                     if target > chunk.instructions.len() {
@@ -463,7 +463,7 @@ impl<'a> VM<'a> {
                     self.iter_stack.push(frame);
                 }
                 OpCode::ForIter => {
-                    if self.budget == 0 { return Err(VmErr::Budget); }
+                    if self.budget == 0 { return Err(cold_budget()); }
                     self.budget -= 1;
                     if self.heap.needs_gc() { self.collect(slots); }
                     match self.iter_stack.last_mut().and_then(|f| f.next_item()) {
@@ -496,7 +496,7 @@ impl<'a> VM<'a> {
                 }
                 OpCode::Call => {
                     let argc = op as usize;
-                    if self.depth >= self.max_calls { return Err(VmErr::CallDepth); }
+                    if self.depth >= self.max_calls { return Err(cold_depth()); }
                     let mut args: Vec<Val> = (0..argc).map(|_| self.pop()).collect::<Result<_,_>>()?;
                     args.reverse();
                     let callee = self.pop()?;

compiler/src/modules/vm/types.rs

@@ -189,7 +189,7 @@ impl HeapPool {
                 if let Some(&idx) = self.strings.get(s) { return Ok(Val::heap(idx)); }
             }
         }
-        if self.usage() >= self.limit { return Err(VmErr::Heap); }
+        if self.usage() >= self.limit { return Err(cold_heap()); }
         if self.objects.len() >= (1 << 28)  { return Err(VmErr::Heap); }
 
         let idx = if let Some(i) = self.free_list.pop() {
@@ -380,4 +380,13 @@ pub fn fpowf(base: f64, exp: f64) -> f64 {
         return f64::NAN;
     }
     fexp(exp * fln(base))
-}
+}
+
+/*
+Cold Error Constructors
+    Out-of-line error paths keep hot dispatch loop linear for instruction cache.
+*/
+
+#[cold] #[inline(never)] pub fn cold_heap() -> VmErr { VmErr::Heap }
+#[cold] #[inline(never)] pub fn cold_budget() -> VmErr { VmErr::Budget }
+#[cold] #[inline(never)] pub fn cold_depth() -> VmErr { VmErr::CallDepth }