This commit is contained in:
2026-03-24 13:40:36 +00:00
parent 29056ce0ad
commit 6423c6b4bc
6 changed files with 25 additions and 437 deletions
@@ -970,119 +970,6 @@ impl VirtualMachine {
})?;
self.operand_stack.truncate(frame.scope_stack_base);
}
OpCode::Alloc => {
// Allocate a new gate with given type and number of slots.
let (type_id, slots_u32) = instr
.imm_u32x2()
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
let slots = slots_u32 as usize;
// Bump-allocate on the heap and zero-initialize with Null.
let base_idx = self.heap.len();
for _ in 0..slots {
self.heap.push(Value::Null);
}
// Insert entry into gate pool; GateId is index in this pool.
let entry =
GateEntry { alive: true, base: base_idx as u32, slots: slots_u32, type_id };
let gate_id = self.gate_pool.len() as u32;
self.gate_pool.push(entry);
// Push a Gate value that now carries the GateId instead of a heap base.
self.push(Value::Gate(gate_id as usize));
}
OpCode::GateLoad => {
let offset = instr
.imm_u32()
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
as usize;
let ref_val = self.pop().map_err(|e| LogicalFrameEndingReason::Panic(e))?;
if let Value::Gate(gid_usize) = ref_val {
let gid = gid_usize as GateId;
let entry = self
.resolve_gate(gid, OpCode::GateLoad as u16, start_pc as u32)
.map_err(|t| t)?;
// bounds check against slots
let off_u32 = offset as u32;
if off_u32 >= entry.slots {
return Err(self.trap(
TRAP_OOB,
OpCode::GateLoad as u16,
format!("Out-of-bounds heap access at offset {}", offset),
start_pc as u32,
));
}
let heap_idx = entry.base as usize + offset;
let val = self.heap.get(heap_idx).cloned().ok_or_else(|| {
// Should not happen if pool and heap are consistent, but keep defensive.
self.trap(
TRAP_OOB,
OpCode::GateLoad as u16,
format!("Out-of-bounds heap access at offset {}", offset),
start_pc as u32,
)
})?;
self.push(val);
} else {
return Err(self.trap(
TRAP_TYPE,
OpCode::GateLoad as u16,
"Expected gate handle for GATE_LOAD".to_string(),
start_pc as u32,
));
}
}
OpCode::GateStore => {
let offset = instr
.imm_u32()
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
as usize;
let val = self.pop().map_err(|e| LogicalFrameEndingReason::Panic(e))?;
let ref_val = self.pop().map_err(|e| LogicalFrameEndingReason::Panic(e))?;
if let Value::Gate(gid_usize) = ref_val {
let gid = gid_usize as GateId;
let entry = self
.resolve_gate(gid, OpCode::GateStore as u16, start_pc as u32)
.map_err(|t| t)?;
let off_u32 = offset as u32;
if off_u32 >= entry.slots {
return Err(self.trap(
TRAP_OOB,
OpCode::GateStore as u16,
format!("Out-of-bounds heap access at offset {}", offset),
start_pc as u32,
));
}
let heap_idx = entry.base as usize + offset;
if heap_idx >= self.heap.len() {
return Err(self.trap(
TRAP_OOB,
OpCode::GateStore as u16,
format!("Out-of-bounds heap access at offset {}", offset),
start_pc as u32,
));
}
self.heap[heap_idx] = val;
} else {
return Err(self.trap(
TRAP_TYPE,
OpCode::GateStore as u16,
"Expected gate handle for GATE_STORE".to_string(),
start_pc as u32,
));
}
}
OpCode::GateBeginPeek
| OpCode::GateEndPeek
| OpCode::GateBeginBorrow
| OpCode::GateEndBorrow
| OpCode::GateBeginMutate
| OpCode::GateEndMutate
| OpCode::GateRetain => {}
OpCode::GateRelease => {
self.pop().map_err(|e| LogicalFrameEndingReason::Panic(e))?;
}
OpCode::Syscall => {
let pc_at_syscall = start_pc as u32;
let id = instr
@@ -1912,134 +1799,19 @@ mod tests {
}
#[test]
fn test_hip_traps_oob() {
let mut native = MockNative;
let mut ctx = HostContext::new(None);
// ALLOC int, 1 -> Gate(0)
// GATE_LOAD 1 -> TRAP_OOB (size is 1, offset 1 is invalid)
let mut rom = Vec::new();
rom.extend_from_slice(&(OpCode::Alloc as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes()); // type_id
rom.extend_from_slice(&1u32.to_le_bytes()); // slots
rom.extend_from_slice(&(OpCode::GateLoad as u16).to_le_bytes());
rom.extend_from_slice(&1u32.to_le_bytes()); // offset 1
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
let mut vm = new_test_vm(rom.clone(), vec![]);
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
match report.reason {
LogicalFrameEndingReason::Trap(trap) => {
assert_eq!(trap.code, TRAP_OOB);
assert_eq!(trap.opcode, OpCode::GateLoad as u16);
assert!(trap.message.contains("Out-of-bounds"));
}
_ => panic!("Expected Trap, got {:?}", report.reason),
}
fn test_hip_traps_oob_removed_legacy() {
// Legacy HIP opcodes removed; test deleted.
assert!(true);
}
#[test]
fn test_hip_traps_type() {
let mut native = MockNative;
let mut ctx = HostContext::new(None);
// PUSH_I32 42
// GATE_LOAD 0 -> TRAP_TYPE (Expected gate handle, got Int32)
let mut rom = Vec::new();
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
rom.extend_from_slice(&42i32.to_le_bytes());
rom.extend_from_slice(&(OpCode::GateLoad as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
let mut vm = new_test_vm(rom.clone(), vec![]);
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
match report.reason {
LogicalFrameEndingReason::Trap(trap) => {
assert_eq!(trap.code, TRAP_TYPE);
assert_eq!(trap.opcode, OpCode::GateLoad as u16);
}
_ => panic!("Expected Trap, got {:?}", report.reason),
}
}
fn test_hip_traps_type_removed_legacy() { assert!(true); }
#[test]
fn test_gate_ids_distinct_and_round_trip() {
let mut native = MockNative;
let mut ctx = HostContext::new(None);
// Program:
// ALLOC(type=0, slots=1) -> [g0]
// ALLOC(type=0, slots=1) -> [g0, g1]
// HALT
let mut rom = Vec::new();
rom.extend_from_slice(&(OpCode::Alloc as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&1u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Alloc as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&1u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
let mut vm = new_test_vm(rom.clone(), vec![]);
vm.run_budget(100, &mut native, &mut ctx).unwrap();
let g1 = vm.pop().unwrap();
let g0 = vm.pop().unwrap();
assert_ne!(g0, g1, "GateIds must be distinct");
// Now test store/load round-trip using a new small program:
// ALLOC(type=0, slots=1) -> [g]
// DUP -> [g, g]
// PushI32 123 -> [g, g, 123]
// GateStore 0 -> []
// GateLoad 0 -> [123]
// HALT
let mut rom = Vec::new();
rom.extend_from_slice(&(OpCode::Alloc as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&1u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Dup as u16).to_le_bytes());
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
rom.extend_from_slice(&123i32.to_le_bytes());
rom.extend_from_slice(&(OpCode::GateStore as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::GateLoad as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
let mut vm = new_test_vm(rom.clone(), vec![]);
vm.run_budget(100, &mut native, &mut ctx).unwrap();
assert_eq!(vm.pop().unwrap(), Value::Int32(123));
}
fn test_gate_ids_distinct_and_round_trip_removed_legacy() { assert!(true); }
#[test]
fn test_invalid_gate_traps() {
let mut native = MockNative;
let mut ctx = HostContext::new(None);
// Program: GATE_LOAD 0; HALT
// We'll seed the operand stack with an invalid GateId before running.
let mut rom = Vec::new();
rom.extend_from_slice(&(OpCode::GateLoad as u16).to_le_bytes());
rom.extend_from_slice(&0u32.to_le_bytes());
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
let mut vm = new_test_vm(rom.clone(), vec![]);
// Push an invalid GateId that is out of range (no allocations were made)
vm.operand_stack.push(Value::Gate(42usize));
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
match report.reason {
LogicalFrameEndingReason::Trap(trap) => {
assert_eq!(trap.code, TRAP_OOB);
assert_eq!(trap.opcode, OpCode::GateLoad as u16);
}
_ => panic!("Expected Trap, got {:?}", report.reason),
}
}
fn test_invalid_gate_traps_removed_legacy() { assert!(true); }
#[test]
fn test_entry_point_ret_with_prepare_call() {