Add generic logical guards and atomic storage publication
This commit is contained in:
@@ -336,6 +336,22 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
||||
emit_u32(parse_u32_any(ops)?, &mut out);
|
||||
}
|
||||
|
||||
"INDEX_GUARD" => {
|
||||
if !ops.is_empty() {
|
||||
return Err(AsmError::InvalidOperand(line.into()));
|
||||
}
|
||||
emit_u16(CoreOpCode::IndexGuard as u16, &mut out);
|
||||
}
|
||||
"STORAGE_PUBLISH" => {
|
||||
let parts: Vec<_> = ops.split(',').map(str::trim).collect();
|
||||
if parts.len() != 4 {
|
||||
return Err(AsmError::InvalidOperand(line.into()));
|
||||
}
|
||||
emit_u16(CoreOpCode::StoragePublish as u16, &mut out);
|
||||
for part in parts {
|
||||
emit_u32(parse_u32_any(part)?, &mut out);
|
||||
}
|
||||
}
|
||||
"STRUCT_GET" | "STRUCT_SET" => {
|
||||
let (a, b) = parse_keyvals(ops)?;
|
||||
let (ty, field) = parse_pair(a, "type", b, "field")?;
|
||||
@@ -345,7 +361,8 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
||||
emit_u32(ty, &mut out);
|
||||
emit_u32(field, &mut out);
|
||||
}
|
||||
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" => {
|
||||
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET"
|
||||
| "ARRAY_CHECK_LENGTH" | "ARRAY_COPY" => {
|
||||
if ops.is_empty() {
|
||||
return Err(AsmError::MissingOperand(line.into()));
|
||||
}
|
||||
@@ -354,6 +371,8 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
||||
"ARRAY_NEW" => CoreOpCode::ArrayNew,
|
||||
"ARRAY_LEN" => CoreOpCode::ArrayLen,
|
||||
"ARRAY_GET" => CoreOpCode::ArrayGet,
|
||||
"ARRAY_CHECK_LENGTH" => CoreOpCode::ArrayCheckLength,
|
||||
"ARRAY_COPY" => CoreOpCode::ArrayCopy,
|
||||
_ => CoreOpCode::ArraySet,
|
||||
};
|
||||
emit_u16(op as u16, &mut out);
|
||||
|
||||
@@ -76,6 +76,14 @@ impl<'a> DecodedInstr<'a> {
|
||||
Ok(f64::from_le_bytes(self.imm.try_into().unwrap()))
|
||||
}
|
||||
|
||||
/// Four independent u32 operands; widths are resolved through the Registry.
|
||||
pub fn imm_u32x4(&self) -> Result<[u32; 4], DecodeError> {
|
||||
self.ensure_len(16)?;
|
||||
Ok(std::array::from_fn(|i| {
|
||||
u32::from_le_bytes(self.imm[i * 4..i * 4 + 4].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> {
|
||||
|
||||
@@ -70,10 +70,18 @@ fn format_operand(op: CoreOpCode, imm: &[u8]) -> String {
|
||||
| CoreOpCode::ArrayNew
|
||||
| CoreOpCode::ArrayLen
|
||||
| CoreOpCode::ArrayGet
|
||||
| CoreOpCode::ArraySet => {
|
||||
| CoreOpCode::ArraySet
|
||||
| CoreOpCode::ArrayCheckLength
|
||||
| CoreOpCode::ArrayCopy => {
|
||||
let v = u32::from_le_bytes(imm.try_into().unwrap());
|
||||
format!("{}", v)
|
||||
}
|
||||
CoreOpCode::StoragePublish => {
|
||||
let fields: [u32; 4] = std::array::from_fn(|i| {
|
||||
u32::from_le_bytes(imm[i * 4..i * 4 + 4].try_into().unwrap())
|
||||
});
|
||||
format!("{}, {}, {}, {}", fields[0], fields[1], fields[2], fields[3])
|
||||
}
|
||||
CoreOpCode::StructGet | CoreOpCode::StructSet => {
|
||||
let ty = u32::from_le_bytes(imm[..4].try_into().unwrap());
|
||||
let field = u32::from_le_bytes(imm[4..].try_into().unwrap());
|
||||
@@ -144,3 +152,21 @@ pub fn disassemble(bytes: &[u8]) -> Result<String, DecodeError> {
|
||||
}
|
||||
Ok(out.join("\n"))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod storage_instruction_tests {
|
||||
#[test]
|
||||
fn storage_operands_roundtrip_and_quad_immediates_never_decode_truncated() {
|
||||
let code = crate::assemble(
|
||||
"INDEX_GUARD\nARRAY_CHECK_LENGTH 7\nARRAY_COPY 8\nSTORAGE_PUBLISH 8, 9, 0, 1",
|
||||
)
|
||||
.unwrap();
|
||||
let text = super::disassemble(&code).unwrap();
|
||||
assert_eq!(crate::assemble(&text).unwrap(), code);
|
||||
let pc = 14;
|
||||
for end in pc + 2..code.len() {
|
||||
assert!(crate::decode_next(pc, &code[..end]).is_err());
|
||||
}
|
||||
assert_eq!(crate::decode_next(pc, &code).unwrap().imm_u32x4().unwrap(), [8, 9, 0, 1]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -201,6 +201,15 @@ pub enum OpCode {
|
||||
ArrayLen = 0xA4,
|
||||
ArrayGet = 0xA5,
|
||||
ArraySet = 0xA6,
|
||||
/// Signed logical index guard; stack [index:i64, exclusive_limit:i64] -> [].
|
||||
IndexGuard = 0xA7,
|
||||
/// Structural Array length check without allocation; TypeId:u32.
|
||||
ArrayCheckLength = 0xA8,
|
||||
/// Complete stored groups, overlap-safe; Array TypeId:u32.
|
||||
ArrayCopy = 0xA9,
|
||||
/// Move/fill array ranges and two selected Struct fields in one attempt.
|
||||
/// Array TypeId, Struct TypeId, first field, second field (four u32).
|
||||
StoragePublish = 0xAA,
|
||||
}
|
||||
|
||||
impl TryFrom<u16> for OpCode {
|
||||
@@ -274,6 +283,10 @@ impl TryFrom<u16> for OpCode {
|
||||
0xA4 => Ok(OpCode::ArrayLen),
|
||||
0xA5 => Ok(OpCode::ArrayGet),
|
||||
0xA6 => Ok(OpCode::ArraySet),
|
||||
0xA7 => Ok(OpCode::IndexGuard),
|
||||
0xA8 => Ok(OpCode::ArrayCheckLength),
|
||||
0xA9 => Ok(OpCode::ArrayCopy),
|
||||
0xAA => Ok(OpCode::StoragePublish),
|
||||
|
||||
_ => Err(format!("Invalid OpCode: 0x{:04X}", value)),
|
||||
}
|
||||
@@ -351,6 +364,9 @@ impl OpCode {
|
||||
OpCode::ArrayLen => 3,
|
||||
OpCode::ArrayGet => 3,
|
||||
OpCode::ArraySet => 4,
|
||||
OpCode::IndexGuard | OpCode::ArrayCheckLength => 2,
|
||||
OpCode::ArrayCopy => 4,
|
||||
OpCode::StoragePublish => 6,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -666,6 +666,30 @@ impl OpCodeSpecExt for OpCode {
|
||||
may_trap: true,
|
||||
is_safepoint: false,
|
||||
},
|
||||
OpCode::IndexGuard => OpcodeSpec {
|
||||
name: "INDEX_GUARD",
|
||||
imm_bytes: 0,
|
||||
pops: Some(2),
|
||||
pushes: Some(0),
|
||||
is_branch: false,
|
||||
is_terminator: false,
|
||||
may_trap: true,
|
||||
is_safepoint: false,
|
||||
},
|
||||
OpCode::ArrayCheckLength | OpCode::ArrayCopy | OpCode::StoragePublish => OpcodeSpec {
|
||||
name: match self {
|
||||
OpCode::ArrayCheckLength => "ARRAY_CHECK_LENGTH",
|
||||
OpCode::ArrayCopy => "ARRAY_COPY",
|
||||
_ => "STORAGE_PUBLISH",
|
||||
},
|
||||
imm_bytes: if *self == OpCode::StoragePublish { 16 } else { 4 },
|
||||
pops: None,
|
||||
pushes: None,
|
||||
is_branch: false,
|
||||
is_terminator: false,
|
||||
may_trap: true,
|
||||
is_safepoint: false,
|
||||
},
|
||||
OpCode::FrameSync => OpcodeSpec {
|
||||
name: "FRAME_SYNC",
|
||||
imm_bytes: 0,
|
||||
|
||||
@@ -133,6 +133,38 @@ impl DecodedInstr<'_> {
|
||||
};
|
||||
(source_layout.storage.slots, pushes)
|
||||
}
|
||||
Op::ArrayCheckLength | Op::ArrayCopy | Op::StoragePublish => {
|
||||
let (array, owner, first, second) = if self.opcode == Op::StoragePublish {
|
||||
let [a, o, f, s] = self.imm_u32x4().map_err(|_| malformed())?;
|
||||
(a, o, f, s)
|
||||
} else {
|
||||
(self.imm_u32().map_err(|_| malformed())?, 0, 0, 0)
|
||||
};
|
||||
let (_, layout) = type_info(array)?;
|
||||
let element = layout.array.ok_or_else(|| bad_category(array))?.element_type_id;
|
||||
let width = registry.type_layout(element).unwrap().storage.slots;
|
||||
match self.opcode {
|
||||
Op::ArrayCheckLength => (1, 0),
|
||||
Op::ArrayCopy => (5, 0),
|
||||
_ => {
|
||||
let (_, layout) = type_info(owner)?;
|
||||
let instance =
|
||||
layout.instance.as_ref().ok_or_else(|| bad_category(owner))?;
|
||||
if first == second {
|
||||
return Err(bad_category(owner).member(second));
|
||||
}
|
||||
let mut slots = 8 + width;
|
||||
for field in [first, second] {
|
||||
let f = instance
|
||||
.fields
|
||||
.get(field as usize)
|
||||
.ok_or_else(|| bad_category(owner).member(field))?;
|
||||
slots += registry.type_layout(f.type_id).unwrap().storage.slots;
|
||||
}
|
||||
(slots, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
Op::StructNew
|
||||
| Op::StructGet
|
||||
| Op::StructSet
|
||||
|
||||
Reference in New Issue
Block a user