pr1.3
This commit is contained in:
@@ -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() {
|
||||
|
||||
Reference in New Issue
Block a user