diff --git a/jam_test_test_match_enum_expression b/jam_test_test_match_enum_expression
deleted file mode 100755
index df80ba2de29c7bf9307897142935539d8528925d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 33696
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
T%^T;rDO5J^{glFgQ#`x@`-G)M

diff --git a/src/jir_codegen.cpp b/src/jir_codegen.cpp
index 34d5ae2..776aab7 100644
--- a/src/jir_codegen.cpp
+++ b/src/jir_codegen.cpp
@@ -591,14 +591,28 @@ static JamValueRef emitInstImpl(JirCodegenCtx &lctx, JirRef r) {
 			return JamLLVMBuildLoad(lctx.ctx.getBuilder(), elemLLVMTy, gep,
 			                        "idx");
 		}
-		// Array case: spill the SSA value to a temp alloca and GEP.
+		// Array case. Arrays are byref (abi::isByRef is always true for
+		// TypeKind::Array), so `emitInst` returns a *pointer* to the
+		// backing storage — GEP straight into it, mirroring Zig's
+		// airArrayElemVal byref branch (references/zig-0.10.1
+		// src/codegen/llvm.zig:5724: resolveInst gives a pointer, then
+		// inBoundsGEP {0, idx}). The previous code unconditionally
+		// spilled `base` into a fresh alloca; for a byref base that
+		// stores the *pointer bits* into a [N]T slot and then indexes
+		// garbage — the bug behind module-const array reads (`TABLE[i]`)
+		// returning junk (a const read re-evaluates its init as an SSA
+		// ArrayLit, which lowers byref to a pointer). Only a genuine
+		// by-value aggregate would need the spill; guard on isByRef.
 		JamValueRef base = emitInst(lctx, inst.a);
-		uint64_t align = lctx.ctx.typeAlign(baseInst.ty);
-		JamValueRef tmp = JamLLVMBuildAlloca(lctx.ctx.getBuilder(), baseLLVMTy,
-		                                     align, "arr.tmp");
-		JamLLVMBuildStore(lctx.ctx.getBuilder(), base, tmp);
+		JamValueRef storage = base;
+		if (!jam::abi::isByRef(baseInst.ty, lctx.ctx)) {
+			uint64_t align = lctx.ctx.typeAlign(baseInst.ty);
+			storage = JamLLVMBuildAlloca(lctx.ctx.getBuilder(), baseLLVMTy,
+			                             align, "arr.tmp");
+			JamLLVMBuildStore(lctx.ctx.getBuilder(), base, storage);
+		}
 		JamValueRef gep = JamLLVMBuildArrayGEP(
-		    lctx.ctx.getBuilder(), baseLLVMTy, tmp, idxVal, "idx.gep");
+		    lctx.ctx.getBuilder(), baseLLVMTy, storage, idxVal, "idx.gep");
 		return JamLLVMBuildLoad(lctx.ctx.getBuilder(), elemLLVMTy, gep, "idx");
 	}
 	case JirTag::AddrOf: {
diff --git a/tests/unit/test_const_array_index.jam b/tests/unit/test_const_array_index.jam
new file mode 100644
index 0000000..4136d2c
--- /dev/null
+++ b/tests/unit/test_const_array_index.jam
@@ -0,0 +1,55 @@
+const { assert } = import("test");
+
+// Regression: indexing a module-level `const [N]T = [...]` with a
+// *runtime* index used to return garbage.
+//
+// A module-const read re-evaluates its init expression (astgen.cpp), so
+// `TABLE` lowers to an SSA ArrayLit. Arrays are byref (abi.cpp), so that
+// value is a *pointer* to the storage. JirTag::Index's array case then
+// stored the pointer into a fresh [N]T alloca and indexed *that* —
+// reading the pointer bits instead of the array data. Fixed to GEP the
+// byref pointer directly, like Zig's airArrayElemVal byref branch.
+
+const SMALL: [4]u8 = [10, 20, 30, 40];
+const WIDE:  [8]u32 = [0x100, 0x200, 0x300, 0x400,
+                       0x500, 0x600, 0x700, 0x800];
+const SIGNED: [3]i32 = [0 - 5, 7, 0 - 9];
+
+fn atSmall(i: u32) u8  { return SMALL[i]; }
+fn atWide(i: u32)  u32 { return WIDE[i]; }
+fn atSigned(i: u32) u32 { return SIGNED[i] as u32; }
+
+// Runtime-index loop over a module-const array (the hot-path shape the
+// GTE divide LUT needs).
+fn sumSmall() u32 {
+    var s: u32 = 0;
+    var i: u32 = 0;
+    while (i < 4) {
+        s = s + (SMALL[i] as u32);
+        i = i + 1;
+    }
+    return s;
+}
+
+tfn constArrU8() {
+    assert(atSmall(0) as u32, 10);
+    assert(atSmall(1) as u32, 20);
+    assert(atSmall(2) as u32, 30);
+    assert(atSmall(3) as u32, 40);
+}
+
+tfn constArrU32() {
+    assert(atWide(0), 0x100);
+    assert(atWide(3), 0x400);
+    assert(atWide(7), 0x800);
+}
+
+tfn constArrSigned() {
+    assert(atSigned(0), 0xFFFFFFFB);   // -5 sign-extended
+    assert(atSigned(1), 7);
+    assert(atSigned(2), 0xFFFFFFF7);   // -9 sign-extended
+}
+
+tfn constArrLoopSum() {
+    assert(sumSmall(), 100);           // 10+20+30+40
+}