refactor(vm)!: remove publication and logical guard opcodes
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good

Remove INDEX_GUARD, ARRAY_CHECK_LENGTH, STORAGE_PUBLISH and FIELDS_PUBLISH
from decoding, metadata, tooling, verification and execution. Keep ARRAY_LEN
and overlap-safe ARRAY_COPY with complete-group ownership and early charging
of calculable copy work, including refused attempts.

Update specifications, producer handoff, qualification evidence and lessons.
Share collection test support and remove redundant Copy clones for Clippy.

Validation: make ci-domains passed with 1,095 workspace tests, five separately
executed debugger socket tests and all 15 unchanged coverage domain gates.
VM release, resource diagnostics and layer/quality suites also passed.

BREAKING CHANGE: PBX using opcodes 0xA7, 0xA8, 0xAA or 0xAB is rejected,
including unreachable instructions. Consumers must adapt their emission and
collection algorithms or operational guarantees.
This commit is contained in:
2026-10-23 23:37:56 +01:00
parent 69ad1931de
commit dcf6561ea7
27 changed files with 1407 additions and 1013 deletions
@@ -336,22 +336,6 @@ 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")?;
@@ -361,18 +345,15 @@ 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"
| "ARRAY_CHECK_LENGTH" | "ARRAY_COPY" | "FIELDS_PUBLISH" => {
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" | "ARRAY_COPY" => {
if ops.is_empty() {
return Err(AsmError::MissingOperand(line.into()));
}
let op = match mn {
"FIELDS_PUBLISH" => CoreOpCode::FieldsPublish,
"STRUCT_NEW" => CoreOpCode::StructNew,
"ARRAY_NEW" => CoreOpCode::ArrayNew,
"ARRAY_LEN" => CoreOpCode::ArrayLen,
"ARRAY_GET" => CoreOpCode::ArrayGet,
"ARRAY_CHECK_LENGTH" => CoreOpCode::ArrayCheckLength,
"ARRAY_COPY" => CoreOpCode::ArrayCopy,
_ => CoreOpCode::ArraySet,
};
@@ -76,14 +76,6 @@ 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> {
@@ -72,18 +72,10 @@ fn format_operand(op: CoreOpCode, imm: &[u8]) -> String {
| CoreOpCode::ArrayLen
| CoreOpCode::ArrayGet
| CoreOpCode::ArraySet
| CoreOpCode::ArrayCheckLength
| CoreOpCode::ArrayCopy
| CoreOpCode::FieldsPublish => {
| 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());
@@ -159,21 +151,3 @@ 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]);
}
}
@@ -205,17 +205,8 @@ 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,
/// Atomic full-field writes to schema-selected nullable Struct destinations.
FieldsPublish = 0xAB,
}
impl TryFrom<u16> for OpCode {
@@ -291,11 +282,7 @@ 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),
0xAB => Ok(OpCode::FieldsPublish),
_ => Err(format!("Invalid OpCode: 0x{:04X}", value)),
}
@@ -375,9 +362,7 @@ impl OpCode {
OpCode::ArrayLen => 3,
OpCode::ArrayGet => 3,
OpCode::ArraySet => 4,
OpCode::IndexGuard | OpCode::ArrayCheckLength => 2,
OpCode::ArrayCopy => 4,
OpCode::StoragePublish | OpCode::FieldsPublish => 6,
}
}
}
@@ -686,27 +686,9 @@ 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
| OpCode::FieldsPublish => OpcodeSpec {
name: match self {
OpCode::ArrayCheckLength => "ARRAY_CHECK_LENGTH",
OpCode::ArrayCopy => "ARRAY_COPY",
OpCode::FieldsPublish => "FIELDS_PUBLISH",
_ => "STORAGE_PUBLISH",
},
imm_bytes: if *self == OpCode::StoragePublish { 16 } else { 4 },
OpCode::ArrayCopy => OpcodeSpec {
name: "ARRAY_COPY",
imm_bytes: 4,
pops: None,
pushes: None,
is_branch: false,
@@ -150,59 +150,11 @@ impl DecodedInstr<'_> {
}
(pops, 1)
}
Op::FieldsPublish => {
let schema = self.imm_u32().map_err(|_| malformed())?;
let (decl, _) = type_info(schema)?;
let TypeKind::Struct(entries) = &decl.kind else {
return Err(bad_category(schema));
};
let mut slots = 0u32;
for entry in entries {
let (owner, layout) = type_info(entry.type_id.0)?;
if !matches!(owner.kind, TypeKind::Struct(_)) {
return Err(bad_category(entry.type_id.0));
}
let fields =
u32::try_from(layout.instance.as_ref().unwrap().initialization_slots)
.map_err(|_| malformed())?;
slots = slots
.checked_add(1)
.and_then(|n| n.checked_add(fields))
.ok_or_else(malformed)?;
}
(slots, 0)
}
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)
};
Op::ArrayCopy => {
let array = self.imm_u32().map_err(|_| malformed())?;
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)
}
}
layout.array.ok_or_else(|| bad_category(array))?;
(5, 0)
}
Op::StructNew
| Op::StructGet