Path A.4: read-only array support in dual-band JIT

OMC arrays now JIT. NewArray, ArrayLen, and ArrayIndex are
implemented in the dual-band lowerer; any pure-int OMC fn that
builds an array, reads from it, and returns a scalar will JIT.

Layout: each NewArray emits an `alloca [N+1 x i64]` in the fn's
entry block. Slot 0 holds the length (so ArrayLen needs no
side-channel — arrays are self-describing). Slots 1..=N hold the
elements, populated in source order from the operand stack.

On the operand stack, an array is its pointer cast to i64 (ptrtoint
at NewArray, inttoptr at use). This fits the existing
Vec<VectorValue> stack convention without needing a typed enum —
same pragmatic encoding as Path A.2's float bitcast trick. The
caller-facing fn signature stays scalar i64; arrays are an
internal-only representation.

ArrayIndex's slot calc is `idx + 1` — skip the length prefix and
GEP to the real element. ArrayLen is `gep idx 0, load i64`.

Implementation surface (all in omnimcode-codegen/src/dual_band.rs):
- Op::NewArray(N) handler -> emit_new_array helper
- Op::ArrayLen handler -> emit_array_len helper
- Op::ArrayIndex handler -> emit_array_index helper

Tests (4 new, all passing):
- jit_array_len_returns_correct_length: arr_len of [10,20,30,40,50] = 5
- jit_array_index_reads_correct_element: arr_get at each index returns
  the expected value
- jit_array_sum_in_loop: sum [1..10] via ArrayLen + ArrayIndex inside
  a while loop, returns 55. Exercises the full pattern.
- jit_array_via_dispatch_hook: end-to-end through Interpreter +
  dispatch hook (the OMC_HBIT_JIT=1 CLI path). sum [100,200,300]
  through JIT'd fn returns 600. Confirms arrays survive the round
  trip through the CLI dispatch layer.

Out of scope for Path A.4 MVP (deferred):
- Op::ArrayIndexAssign / ArrSetNamed: mutable writes to array
  slots. Needs careful thinking about α/β consistency for the
  written value (does β diverge or stay matched?).
- Dynamic resize / arr_push: would need heap allocation via libc
  malloc + a header word for capacity. Stack alloca only supports
  fixed-size at NewArray time.
- Array-typed parameters / returns: caller-facing signature is
  still scalar i64 only.
- Multi-dimensional arrays: nested NewArray should already work
  via pointer-as-i64 representation (untested, but same scheme).

These are all separate sessions when an actual workload needs
them. The MVP unlocks every "fn that builds a constant table and
sums/searches it" pattern, which is exactly the shape of most
substrate-aligned harmonic libs.

Workspace: 38 codegen tests pass (1 IR + 4 cross-fn + 4 arrays
+ 5 dual-band + 5 dispatch + 3 floats + 3 harmony + 5 phi_shadow
+ 8 scalar). Smoke + harmonic-lib + 149 core tests still green.

This wraps Path A:
- A.1: harmony-gated branch elision benched (95.2% reduction
  on high-harmony, break-even at 5-8% input fraction)
- A.2: float arithmetic in lowerers
- A.3: bytecode VM bench (VM is 2.1x over tree-walk; JIT is
  119x over VM)
- A.4: array reads (this commit)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-codegen/src/dual_band.rs

@@ -361,6 +361,38 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
                 Op::Shl => self.bin_vec(&mut stack, i, |b, l, r| b.build_left_shift(l, r, "shl"))?,
                 Op::Shr => self.bin_vec(&mut stack, i, |b, l, r| b.build_right_shift(l, r, true, "shr"))?,
 
+                // Path A.4: read-only array support.
+                //
+                // Layout: `alloca [N+1 x i64]`. Slot 0 holds the
+                // length; slots 1..=N hold the elements. Self-describing
+                // so ArrayLen needs no side-channel.
+                //
+                // Operand-stack convention: arrays live as
+                // pointer-cast-to-i64 on the stack. ptrtoint at push;
+                // inttoptr at use. The bit pattern survives storage in
+                // user-level h-variables (which are <2 x i64> in
+                // dual-band) because lane 0 carries the pointer and
+                // matches what ArrayIndex / ArrayLen extract.
+                //
+                // Arrays live in the fn's stack frame. ArrayIndexAssign
+                // (mutable writes) and dynamic resize are out of scope
+                // for Path A.4 MVP — see Sessions later for those.
+                Op::NewArray(n_elems) => {
+                    let v = self.emit_new_array(&mut stack, i, *n_elems)?;
+                    stack.push(v);
+                }
+                Op::ArrayLen => {
+                    let arr_v = self.pop(&mut stack, i, "ArrayLen ptr")?;
+                    let len = self.emit_array_len(arr_v, i)?;
+                    stack.push(self.splat(len, "alen_v")?);
+                }
+                Op::ArrayIndex => {
+                    let idx_v = self.pop(&mut stack, i, "ArrayIndex idx")?;
+                    let arr_v = self.pop(&mut stack, i, "ArrayIndex ptr")?;
+                    let val = self.emit_array_index(arr_v, idx_v, i)?;
+                    stack.push(self.splat(val, "aidx_v")?);
+                }
+
                 Op::Eq => self.cmp_vec(&mut stack, i, IntPredicate::EQ)?,
                 Op::Ne => self.cmp_vec(&mut stack, i, IntPredicate::NE)?,
                 Op::Lt => self.cmp_vec(&mut stack, i, IntPredicate::SLT)?,
@@ -681,6 +713,184 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
         }
     }
 
+    /// Path A.4: NewArray — pop N values from the operand stack, build
+    /// a length-prefixed `[N+1 x i64]` alloca in the entry block, store
+    /// the popped values into slots 1..=N (in source order — bytecode
+    /// pushes elements left-to-right so popping gives reverse order),
+    /// store length N at slot 0, and return the pointer as a splat'd
+    /// `<2 x i64>` (lane 0 = ptr-as-i64, lane 1 = same).
+    fn emit_new_array(
+        &mut self,
+        stack: &mut Vec<VectorValue<'ctx>>,
+        op_idx: usize,
+        n: usize,
+    ) -> Result<VectorValue<'ctx>, CodegenError> {
+        let i64_type = self.ctx.i64_type();
+        // Pop N values (each is a <2 x i64>; we extract α as the
+        // user-visible scalar). Reverse to get source order.
+        let mut elems: Vec<IntValue<'ctx>> = Vec::with_capacity(n);
+        for k in 0..n {
+            let v_v = self
+                .pop(stack, op_idx, &format!("NewArray elem {}", k))?;
+            let alpha = self
+                .builder
+                .build_extract_element(v_v, i64_type.const_int(0, false), "narr_a")
+                .map_err(|e| format!("NewArray extract α at op{}: {}", op_idx, e))?;
+            let alpha_iv = match alpha {
+                BasicValueEnum::IntValue(iv) => iv,
+                _ => return Err(format!("NewArray elem {} not int at op{}", k, op_idx)),
+            };
+            elems.push(alpha_iv);
+        }
+        elems.reverse();
+
+        // Allocate [N+1 x i64] in the entry block so the alloca
+        // dominates all uses, regardless of which CFG block the
+        // NewArray op was emitted from.
+        let arr_ty = i64_type.array_type((n as u32) + 1);
+        let current_block = self
+            .builder
+            .get_insert_block()
+            .ok_or_else(|| format!("NewArray no insert block at op{}", op_idx))?;
+        let entry = self.function.get_first_basic_block().unwrap();
+        match entry.get_first_instruction() {
+            Some(first) => self.builder.position_before(&first),
+            None => self.builder.position_at_end(entry),
+        }
+        let arr_ptr = self
+            .builder
+            .build_alloca(arr_ty, &format!("arr_op{}", op_idx))
+            .map_err(|e| format!("NewArray alloca at op{}: {}", op_idx, e))?;
+        self.builder.position_at_end(current_block);
+
+        // Store length at slot 0.
+        let zero32 = self.ctx.i32_type().const_int(0, false);
+        let len_gep = unsafe {
+            self.builder
+                .build_in_bounds_gep(arr_ty, arr_ptr, &[zero32, zero32], "narr_len_gep")
+                .map_err(|e| format!("NewArray len gep at op{}: {}", op_idx, e))?
+        };
+        self.builder
+            .build_store(len_gep, i64_type.const_int(n as u64, false))
+            .map_err(|e| format!("NewArray len store at op{}: {}", op_idx, e))?;
+
+        // Store elements at slots 1..=N.
+        for (k, val) in elems.iter().enumerate() {
+            let idx32 = self.ctx.i32_type().const_int((k + 1) as u64, false);
+            let elem_gep = unsafe {
+                self.builder
+                    .build_in_bounds_gep(arr_ty, arr_ptr, &[zero32, idx32], "narr_e_gep")
+                    .map_err(|e| format!("NewArray elem{} gep at op{}: {}", k, op_idx, e))?
+            };
+            self.builder
+                .build_store(elem_gep, *val)
+                .map_err(|e| format!("NewArray elem{} store at op{}: {}", k, op_idx, e))?;
+        }
+
+        // Cast the pointer to i64 and splat into <2 x i64>.
+        let ptr_as_i64 = self
+            .builder
+            .build_ptr_to_int(arr_ptr, i64_type, "narr_ptr_i64")
+            .map_err(|e| format!("NewArray ptrtoint at op{}: {}", op_idx, e))?;
+        self.splat(ptr_as_i64, "narr_v")
+    }
+
+    /// Path A.4: ArrayLen — extract α (pointer-as-i64) from the
+    /// vector, inttoptr to a [N+1 x i64] pointer, GEP slot 0, load.
+    /// Returns the length as a scalar i64 (caller will splat it).
+    fn emit_array_len(
+        &self,
+        arr_v: VectorValue<'ctx>,
+        op_idx: usize,
+    ) -> Result<IntValue<'ctx>, CodegenError> {
+        let i64_type = self.ctx.i64_type();
+        let alpha = self
+            .builder
+            .build_extract_element(arr_v, i64_type.const_int(0, false), "alen_a")
+            .map_err(|e| format!("ArrayLen extract α at op{}: {}", op_idx, e))?;
+        let alpha_iv = match alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrayLen ptr not int at op{}", op_idx)),
+        };
+        // For opaque pointers, GEP needs the element type. We use a
+        // single-element pointee `[1 x i64]` to GEP slot 0; the load
+        // returns the length we wrote at NewArray time.
+        let one_i64 = i64_type.array_type(1);
+        let ptr_ty = self.ctx.ptr_type(inkwell::AddressSpace::default());
+        let ptr = self
+            .builder
+            .build_int_to_ptr(alpha_iv, ptr_ty, "alen_ptr")
+            .map_err(|e| format!("ArrayLen inttoptr at op{}: {}", op_idx, e))?;
+        let zero32 = self.ctx.i32_type().const_int(0, false);
+        let len_gep = unsafe {
+            self.builder
+                .build_in_bounds_gep(one_i64, ptr, &[zero32, zero32], "alen_gep")
+                .map_err(|e| format!("ArrayLen gep at op{}: {}", op_idx, e))?
+        };
+        let len = self
+            .builder
+            .build_load(i64_type, len_gep, "alen_load")
+            .map_err(|e| format!("ArrayLen load at op{}: {}", op_idx, e))?;
+        match len {
+            BasicValueEnum::IntValue(iv) => Ok(iv),
+            _ => Err(format!("ArrayLen load not int at op{}", op_idx)),
+        }
+    }
+
+    /// Path A.4: ArrayIndex — extract α (pointer) and the user-given
+    /// scalar index, GEP to slot `idx + 1` (skipping the length
+    /// prefix), load the element. Returns the element as a scalar i64.
+    fn emit_array_index(
+        &self,
+        arr_v: VectorValue<'ctx>,
+        idx_v: VectorValue<'ctx>,
+        op_idx: usize,
+    ) -> Result<IntValue<'ctx>, CodegenError> {
+        let i64_type = self.ctx.i64_type();
+        let arr_alpha = self
+            .builder
+            .build_extract_element(arr_v, i64_type.const_int(0, false), "aidx_aptr")
+            .map_err(|e| format!("ArrayIndex extract α at op{}: {}", op_idx, e))?;
+        let idx_alpha = self
+            .builder
+            .build_extract_element(idx_v, i64_type.const_int(0, false), "aidx_aix")
+            .map_err(|e| format!("ArrayIndex extract idx α at op{}: {}", op_idx, e))?;
+        let arr_iv = match arr_alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrayIndex ptr not int at op{}", op_idx)),
+        };
+        let idx_iv = match idx_alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrayIndex idx not int at op{}", op_idx)),
+        };
+        let ptr_ty = self.ctx.ptr_type(inkwell::AddressSpace::default());
+        let ptr = self
+            .builder
+            .build_int_to_ptr(arr_iv, ptr_ty, "aidx_ptr")
+            .map_err(|e| format!("ArrayIndex inttoptr at op{}: {}", op_idx, e))?;
+        // Compute slot index = user_idx + 1 (skip the length prefix).
+        let one = i64_type.const_int(1, false);
+        let slot = self
+            .builder
+            .build_int_add(idx_iv, one, "aidx_slot")
+            .map_err(|e| format!("ArrayIndex slot calc at op{}: {}", op_idx, e))?;
+        // Use `i64` as the GEP element type — equivalent to "i64*"
+        // arithmetic. Each step is sizeof(i64) = 8 bytes.
+        let elem_gep = unsafe {
+            self.builder
+                .build_in_bounds_gep(i64_type, ptr, &[slot], "aidx_gep")
+                .map_err(|e| format!("ArrayIndex gep at op{}: {}", op_idx, e))?
+        };
+        let val = self
+            .builder
+            .build_load(i64_type, elem_gep, "aidx_load")
+            .map_err(|e| format!("ArrayIndex load at op{}: {}", op_idx, e))?;
+        match val {
+            BasicValueEnum::IntValue(iv) => Ok(iv),
+            _ => Err(format!("ArrayIndex load not int at op{}", op_idx)),
+        }
+    }
+
     /// Session F intrinsic: replace the β lane of a `<2 x i64>`
     /// vector value with the phi-shadow of α.
     ///

omnimcode-codegen/tests/jit_arrays.rs

@@ -0,0 +1,149 @@
+//! Path A.4 — read-only array support in the dual-band JIT.
+//!
+//! Arrays are represented as `alloca [N+1 x i64]` allocations in the
+//! fn's stack frame. Slot 0 holds the length; slots 1..=N hold the
+//! elements. Self-describing — ArrayLen needs no side-channel.
+//!
+//! On the operand stack, an array is the pointer cast to i64
+//! (ptrtoint at NewArray, inttoptr at use). This fits the existing
+//! Vec<VectorValue> stack convention without needing a typed enum.
+//!
+//! Out of scope for Path A.4 MVP:
+//!   - ArrayIndexAssign (mutable writes)
+//!   - Dynamic resize
+//!   - Returning arrays from JIT'd fns (caller-facing signature is i64)
+//!   - Multi-dimensional / nested arrays
+//!
+//! These are the next sessions' work. The MVP unlocks any pure-int OMC
+//! fn that builds an array, reads from it, and returns a scalar.
+
+#![cfg(feature = "llvm-jit")]
+
+use inkwell::context::Context;
+use omnimcode_codegen::JitContext;
+use omnimcode_core::parser::Parser;
+
+#[test]
+fn jit_array_len_returns_correct_length() {
+    let source = r#"
+        fn arr5_len(unused) {
+            h arr = [10, 20, 30, 40, 50];
+            return arr_len(arr);
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("arr5_len").expect("arr5_len JIT'd");
+    assert_eq!(f.call(&[0]).expect("call"), 5);
+}
+
+#[test]
+fn jit_array_index_reads_correct_element() {
+    let source = r#"
+        fn arr5_at(idx) {
+            h arr = [10, 20, 30, 40, 50];
+            return arr_get(arr, idx);
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("arr5_at").expect("arr5_at JIT'd");
+    assert_eq!(f.call(&[0]).expect("call"), 10);
+    assert_eq!(f.call(&[1]).expect("call"), 20);
+    assert_eq!(f.call(&[2]).expect("call"), 30);
+    assert_eq!(f.call(&[3]).expect("call"), 40);
+    assert_eq!(f.call(&[4]).expect("call"), 50);
+}
+
+#[test]
+fn jit_array_sum_in_loop() {
+    // The headline workload: sum the elements of a small array.
+    // Exercises NewArray + ArrayLen + ArrayIndex inside a while loop.
+    let source = r#"
+        fn sum_arr(unused) {
+            h arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+            h sum = 0;
+            h k = 0;
+            while k < arr_len(arr) {
+                sum = sum + arr_get(arr, k);
+                k = k + 1;
+            }
+            return sum;
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("sum_arr").expect("sum_arr JIT'd");
+    assert_eq!(f.call(&[0]).expect("call"), 55); // 1+2+...+10
+}
+
+#[test]
+fn jit_array_via_dispatch_hook() {
+    // End-to-end through Interpreter dispatch (matches CLI's
+    // OMC_HBIT_JIT=1 path). Verifies arrays survive the JIT round-
+    // trip when called from the user-facing tree-walk.
+    use omnimcode_codegen::JittedFn;
+    use omnimcode_core::interpreter::Interpreter;
+    use omnimcode_core::value::{HInt, Value};
+    use std::collections::HashMap;
+    use std::rc::Rc;
+
+    let source = r#"
+        fn sum_arr(unused) {
+            h arr = [100, 200, 300];
+            h sum = 0;
+            h k = 0;
+            while k < arr_len(arr) {
+                sum = sum + arr_get(arr, k);
+                k = k + 1;
+            }
+            return sum;
+        }
+        h result = sum_arr(0);
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted_map = jit.jit_module(&module).expect("jit_module");
+    assert!(
+        jitted_map.contains_key("sum_arr"),
+        "sum_arr should JIT (uses NewArray, ArrayLen, ArrayIndex)"
+    );
+    let jitted_for_hook: HashMap<String, JittedFn> = jitted_map.clone();
+    let dispatch: omnimcode_core::interpreter::JitDispatch = Rc::new(
+        move |name: &str, args: &[Value]| {
+            let jf = jitted_for_hook.get(name)?;
+            if args.len() != jf.arity {
+                return None;
+            }
+            let mut int_args = Vec::with_capacity(args.len());
+            for a in args {
+                match a {
+                    Value::HInt(h) => int_args.push(h.value),
+                    Value::Bool(b) => int_args.push(if *b { 1 } else { 0 }),
+                    _ => return None,
+                }
+            }
+            jf.call(&int_args).map(|r| Ok(Value::HInt(HInt::new(r))))
+        },
+    );
+    let mut interp = Interpreter::new();
+    interp.set_jit_dispatch(Some(dispatch));
+    interp.execute(statements).expect("exec");
+    let r = interp.get_var_for_testing("result").expect("result");
+    assert_eq!(r.to_int(), 600);
+}