pr 02
This commit is contained in:
@@ -0,0 +1,205 @@
|
||||
//! Canonical bytecode decoder for Prometeu Bytecode (PBC).
|
||||
//!
|
||||
//! Single source of truth for instruction decoding used by compiler/linker/verifier/VM.
|
||||
//!
|
||||
//! Contract:
|
||||
//! - Instructions are encoded as: [opcode: u16 LE][immediate: spec.imm_bytes]
|
||||
//! - `decode_next(pc, bytes)` returns a typed `DecodedInstr` with canonical `next_pc`.
|
||||
//! - Immediate helpers validate sizes deterministically and return explicit errors.
|
||||
|
||||
use crate::opcode::OpCode;
|
||||
use crate::opcode_spec::{OpCodeSpecExt, OpcodeSpec};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum DecodeError {
|
||||
TruncatedOpcode { pc: usize },
|
||||
UnknownOpcode { pc: usize, opcode: u16 },
|
||||
TruncatedImmediate { pc: usize, opcode: OpCode, need: usize, have: usize },
|
||||
ImmediateSizeMismatch { pc: usize, opcode: OpCode, expected: usize, actual: usize },
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct DecodedInstr<'a> {
|
||||
pub opcode: OpCode,
|
||||
pub pc: usize,
|
||||
pub next_pc: usize,
|
||||
/// Raw immediate bytes slice, guaranteed to have length `opcode.spec().imm_bytes`.
|
||||
pub imm: &'a [u8],
|
||||
}
|
||||
|
||||
impl<'a> DecodedInstr<'a> {
|
||||
#[inline]
|
||||
fn ensure_len(&self, expected: usize) -> Result<(), DecodeError> {
|
||||
if self.imm.len() != expected {
|
||||
return Err(DecodeError::ImmediateSizeMismatch {
|
||||
pc: self.pc,
|
||||
opcode: self.opcode,
|
||||
expected,
|
||||
actual: self.imm.len(),
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_u8(&self) -> Result<u8, DecodeError> {
|
||||
self.ensure_len(1)?;
|
||||
Ok(self.imm[0])
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_u16(&self) -> Result<u16, DecodeError> {
|
||||
self.ensure_len(2)?;
|
||||
Ok(u16::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_u32(&self) -> Result<u32, DecodeError> {
|
||||
self.ensure_len(4)?;
|
||||
Ok(u32::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_i32(&self) -> Result<i32, DecodeError> {
|
||||
self.ensure_len(4)?;
|
||||
Ok(i32::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_i64(&self) -> Result<i64, DecodeError> {
|
||||
self.ensure_len(8)?;
|
||||
Ok(i64::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn imm_f64(&self) -> Result<f64, DecodeError> {
|
||||
self.ensure_len(8)?;
|
||||
Ok(f64::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
/// Helper for opcodes carrying two u32 values packed in 8 bytes (e.g., ALLOC meta).
|
||||
#[inline]
|
||||
pub fn imm_u32x2(&self) -> Result<(u32, u32), DecodeError> {
|
||||
self.ensure_len(8)?;
|
||||
let a = u32::from_le_bytes(self.imm[0..4].try_into().unwrap());
|
||||
let b = u32::from_le_bytes(self.imm[4..8].try_into().unwrap());
|
||||
Ok((a, b))
|
||||
}
|
||||
}
|
||||
|
||||
/// Decodes the instruction at program counter `pc` from `bytes`.
|
||||
/// Returns the decoded instruction with canonical `next_pc`.
|
||||
#[inline]
|
||||
pub fn decode_next<'a>(pc: usize, bytes: &'a [u8]) -> Result<DecodedInstr<'a>, DecodeError> {
|
||||
if pc + 2 > bytes.len() {
|
||||
return Err(DecodeError::TruncatedOpcode { pc });
|
||||
}
|
||||
|
||||
let opcode_val = u16::from_le_bytes([bytes[pc], bytes[pc + 1]]);
|
||||
let opcode = OpCode::try_from(opcode_val)
|
||||
.map_err(|_| DecodeError::UnknownOpcode { pc, opcode: opcode_val })?;
|
||||
|
||||
let spec: OpcodeSpec = opcode.spec();
|
||||
let imm_start = pc + 2;
|
||||
let imm_end = imm_start + (spec.imm_bytes as usize);
|
||||
|
||||
if imm_end > bytes.len() {
|
||||
return Err(DecodeError::TruncatedImmediate {
|
||||
pc,
|
||||
opcode,
|
||||
need: spec.imm_bytes as usize,
|
||||
have: bytes.len().saturating_sub(imm_start),
|
||||
});
|
||||
}
|
||||
|
||||
Ok(DecodedInstr {
|
||||
opcode,
|
||||
pc,
|
||||
next_pc: imm_end,
|
||||
imm: &bytes[imm_start..imm_end],
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::asm::{assemble, Asm, Operand};
|
||||
use crate::opcode::OpCode;
|
||||
|
||||
#[test]
|
||||
fn decode_basic_no_imm() {
|
||||
// Encode a NOP (0x0000)
|
||||
let rom = assemble(&[Asm::Op(OpCode::Nop, vec![])]).unwrap();
|
||||
let d = decode_next(0, &rom).unwrap();
|
||||
assert_eq!(d.opcode, OpCode::Nop);
|
||||
assert_eq!(d.pc, 0);
|
||||
assert_eq!(d.next_pc, 2);
|
||||
assert_eq!(d.imm.len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_with_u32_imm() {
|
||||
// PUSH_CONST 0x11223344
|
||||
let rom = assemble(&[Asm::Op(OpCode::PushConst, vec![Operand::U32(0x11223344)])]).unwrap();
|
||||
let d = decode_next(0, &rom).unwrap();
|
||||
assert_eq!(d.opcode, OpCode::PushConst);
|
||||
assert_eq!(d.imm_u32().unwrap(), 0x11223344);
|
||||
assert_eq!(d.next_pc, 2 + 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_with_u8_imm() {
|
||||
// PUSH_BOOL true
|
||||
let rom = assemble(&[Asm::Op(OpCode::PushBool, vec![Operand::Bool(true)])]).unwrap();
|
||||
let d = decode_next(0, &rom).unwrap();
|
||||
assert_eq!(d.opcode, OpCode::PushBool);
|
||||
assert_eq!(d.imm.len(), 1);
|
||||
assert_eq!(d.imm_u8().unwrap(), 1);
|
||||
assert_eq!(d.next_pc, 2 + 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_with_i64_and_f64() {
|
||||
// PUSH_I64, PUSH_F64
|
||||
let rom = assemble(&[
|
||||
Asm::Op(OpCode::PushI64, vec![Operand::I64(-123)]),
|
||||
Asm::Op(OpCode::PushF64, vec![Operand::F64(3.25)]),
|
||||
]).unwrap();
|
||||
|
||||
let d0 = decode_next(0, &rom).unwrap();
|
||||
assert_eq!(d0.opcode, OpCode::PushI64);
|
||||
assert_eq!(d0.imm_i64().unwrap(), -123);
|
||||
|
||||
let d1 = decode_next(d0.next_pc, &rom).unwrap();
|
||||
assert_eq!(d1.opcode, OpCode::PushF64);
|
||||
assert!((d1.imm_f64().unwrap() - 3.25).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_truncated() {
|
||||
let rom: Vec<u8> = vec![0x00, 0x00]; // NOP complete
|
||||
assert!(matches!(decode_next(1, &rom), Err(DecodeError::TruncatedOpcode { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn roundtrip_encode_decode_table() {
|
||||
let rom = assemble(&[
|
||||
Asm::Op(OpCode::Nop, vec![]),
|
||||
Asm::Op(OpCode::PushConst, vec![Operand::U32(7)]),
|
||||
Asm::Op(OpCode::Jmp, vec![Operand::U32(4)]),
|
||||
Asm::Op(OpCode::PushI64, vec![Operand::I64(42)]),
|
||||
Asm::Op(OpCode::Halt, vec![]),
|
||||
]).unwrap();
|
||||
|
||||
let mut pc = 0usize;
|
||||
let mut decoded = Vec::new();
|
||||
while pc < rom.len() {
|
||||
let d = decode_next(pc, &rom).unwrap();
|
||||
decoded.push(d.opcode);
|
||||
pc = d.next_pc;
|
||||
}
|
||||
|
||||
assert_eq!(decoded, vec![OpCode::Nop, OpCode::PushConst, OpCode::Jmp, OpCode::PushI64, OpCode::Halt]);
|
||||
assert_eq!(pc, rom.len());
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,7 @@ pub mod readwrite;
|
||||
pub mod asm;
|
||||
pub mod disasm;
|
||||
pub mod layout;
|
||||
pub mod decoder;
|
||||
|
||||
mod model;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user