From 8a72058fdefbb587043f570a16334b72426bc0c8 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 29 Oct 2025 21:02:37 +0800 Subject: [PATCH 01/66] chore: add test for std refcell --- .../integration/data/prove-rs/refcell.rs | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 kmir/src/tests/integration/data/prove-rs/refcell.rs diff --git a/kmir/src/tests/integration/data/prove-rs/refcell.rs b/kmir/src/tests/integration/data/prove-rs/refcell.rs new file mode 100644 index 000000000..0771c0eca --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/refcell.rs @@ -0,0 +1,121 @@ +//! Minimal dual-AccountInfo harness for MIR semantics tests. + +use std::cell::{Ref, RefCell, RefMut}; + +trait MiniPack: Copy { + const LEN: usize; + fn pack_into_slice(self, dst: &mut [u8]); + fn unpack_unchecked(src: &[u8]) -> Self + where + Self: Sized; +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct MiniMint { + decimals: u8, + supply: u64, +} + +impl MiniPack for MiniMint { + const LEN: usize = 9; + + fn pack_into_slice(self, dst: &mut [u8]) { + assert_eq!(dst.len(), Self::LEN); + dst[0] = self.decimals; + dst[1..].copy_from_slice(&self.supply.to_le_bytes()); + } + + fn unpack_unchecked(src: &[u8]) -> Self { + let mut supply = [0_u8; 8]; + supply.copy_from_slice(&src[1..]); + Self { + decimals: src[0], + supply: u64::from_le_bytes(supply), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct MiniTokenAccount { + owner: [u8; 8], + amount: u64, + status: u8, +} + +impl MiniPack for MiniTokenAccount { + const LEN: usize = 17; + + fn pack_into_slice(self, dst: &mut [u8]) { + assert_eq!(dst.len(), Self::LEN); + dst[0..8].copy_from_slice(&self.owner); + dst[8..16].copy_from_slice(&self.amount.to_le_bytes()); + dst[16] = self.status; + } + + fn unpack_unchecked(src: &[u8]) -> Self { + let mut owner = [0_u8; 8]; + owner.copy_from_slice(&src[0..8]); + let mut amount = [0_u8; 8]; + amount.copy_from_slice(&src[8..16]); + Self { + owner, + amount: u64::from_le_bytes(amount), + status: src[16], + } + } +} + +pub struct AccountInfo<'a> { + data: RefCell<&'a mut [u8]>, +} + +impl<'a> AccountInfo<'a> { + pub fn new(data: &'a mut [u8]) -> Self { + Self { + data: RefCell::new(data), + } + } + + pub fn borrow_data(&self) -> Ref<'_, [u8]> { + Ref::map(self.data.borrow(), |slice| &**slice) + } + + pub fn borrow_mut_data(&self) -> RefMut<'_, [u8]> { + RefMut::map(self.data.borrow_mut(), |slice| &mut **slice) + } +} + +#[no_mangle] +pub fn dual_account_demo(account_info: &AccountInfo, mint_info: &AccountInfo) -> bool { + let account_read = account_info.borrow_data(); + let mint_read = mint_info.borrow_data(); + let _ = MiniTokenAccount::unpack_unchecked(&account_read); + let _ = MiniMint::unpack_unchecked(&mint_read); + drop(account_read); + drop(mint_read); + + let mut account_write = account_info.borrow_mut_data(); + let mut mint_write = mint_info.borrow_mut_data(); + MiniTokenAccount { + owner: *b"demoacct", + amount: 123, + status: 1, + } + .pack_into_slice(&mut account_write); + MiniMint { + decimals: 9, + supply: 500, + } + .pack_into_slice(&mut mint_write); + + true +} + +fn main() { + let mut account_bytes = [0_u8; MiniTokenAccount::LEN]; + let mut mint_bytes = [0_u8; MiniMint::LEN]; + let account = AccountInfo::new(&mut account_bytes); + let mint = AccountInfo::new(&mut mint_bytes); + let result = dual_account_demo(&account, &mint); + assert!(result); +} From 9f82eec6d80b2cbf77ecbe8f27bac2ecba50cacd Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 14:21:05 +0800 Subject: [PATCH 02/66] chore: add simple test for one struct casting --- .../exec-smir/pointers/struct_cast_fail.rs | 13 + .../pointers/struct_cast_fail.smir.json | 3632 ++++++++++++++++ .../exec-smir/pointers/struct_cast_fail.state | 50 + .../exec-smir/pointers/unsafe_cell_cast.rs | 14 + .../pointers/unsafe_cell_cast.smir.json | 3763 +++++++++++++++++ .../exec-smir/pointers/unsafe_cell_cast.state | 49 + .../src/tests/integration/test_integration.py | 12 + 7 files changed, 7533 insertions(+) create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json create mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs new file mode 100644 index 000000000..cca13da87 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs @@ -0,0 +1,13 @@ +struct Pair { + head: i64, + tail: i8, +} + +fn read_via_cast(pair: &Pair) -> i64 { + unsafe { *(pair as *const Pair as *const i64) } +} + +fn main() { + let pair = Pair { head: 7, tail: 1 }; + assert!(read_via_cast(&pair) == 7); +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json new file mode 100644 index 000000000..2df1fb4bc --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json @@ -0,0 +1,3632 @@ +{ + "name": "struct_cast_fail", + "crate_id": 4745107763802994174, + "allocs": [ + { + "alloc_id": 1, + "ty": 38, + "global_alloc": { + "Memory": { + "bytes": [ + 97, + 115, + 115, + 101, + 114, + 116, + 105, + 111, + 110, + 32, + 102, + 97, + 105, + 108, + 101, + 100, + 58, + 32, + 114, + 101, + 97, + 100, + 95, + 118, + 105, + 97, + 95, + 99, + 97, + 115, + 116, + 40, + 38, + 112, + 97, + 105, + 114, + 41, + 32, + 61, + 61, + 32, + 55 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Not" + } + } + } + ], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h9850ff6d26d0d49cE" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h1f8c021e0ac43527E" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h2d22a339bbdd2052E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h34647d5ce086dc87E" + } + ], + [ + 23, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17ha5dc080083b58409E" + } + ], + [ + 32, + { + "NormalSym": "_ZN16struct_cast_fail13read_via_cast17hcc566435b7abf99eE" + } + ], + [ + 33, + { + "NormalSym": "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" + } + ], + [ + 41, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN16struct_cast_fail13read_via_cast17hcc566435b7abf99eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "read_via_cast", + "id": 6, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 1, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 51 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Move": { + "local": 3, + "projection": [] + } + }, + 25 + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + 26 + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + "Transmute", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + 27 + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "NullaryOp": [ + "AlignOf", + 28 + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Sub", + { + "Copy": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 50, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 27, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Copy": { + "local": 5, + "projection": [] + } + }, + { + "Copy": { + "local": 7, + "projection": [] + } + } + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Copy": { + "local": 8, + "projection": [] + } + }, + { + "Constant": { + "span": 50, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 27, + "id": 10 + } + } + } + ] + } + ] + }, + "span": 50 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Copy": { + "local": 9, + "projection": [] + } + }, + "expected": true, + "msg": { + "MisalignedPointerDereference": { + "required": { + "Copy": { + "local": 6, + "projection": [] + } + }, + "found": { + "Copy": { + "local": 5, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Unreachable" + } + }, + "span": 50 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 50 + } + ], + "terminator": { + "kind": "Return", + "span": 53 + } + } + ], + "locals": [ + { + "ty": 28, + "span": 54, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 55, + "mutability": "Not" + }, + { + "ty": 25, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 56, + "mutability": "Mut" + }, + { + "ty": 26, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 50, + "mutability": "Mut" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "pair", + "source_info": { + "span": 55, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 57 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16struct_cast_fail4main17h10a9db70c2425cf7E", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 7, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 8, + 0, + [], + null, + null + ] + }, + [ + { + "Constant": { + "span": 60, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 7, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 12 + } + } + }, + { + "Constant": { + "span": 61, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 2, + "id": 13 + } + } + } + ] + ] + } + ] + }, + "span": 62 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 63 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 58, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 32, + "id": 11 + } + } + }, + "args": [ + { + "Copy": { + "local": 3, + "projection": [] + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 59 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 2, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 7, + 2 + ] + ], + "otherwise": 3 + } + } + }, + "span": 64 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 66, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 33, + "id": 14 + } + } + }, + "args": [ + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 43, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 0 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 34, + "id": 15 + } + } + } + ], + "destination": { + "local": 4, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 66 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 35, + "span": 68, + "mutability": "Not" + }, + { + "ty": 28, + "span": 59, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 63, + "mutability": "Not" + }, + { + "ty": 36, + "span": 66, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "pair", + "source_info": { + "span": 68, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 69 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17h9664bd899e496584E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::rt::lang_start::<()>", + "id": 0, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 1 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 2 + }, + { + "kind": { + "StorageLive": 8 + }, + "span": 3 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + { + "Closure": [ + 1, + [ + { + "Type": 1 + }, + { + "Type": 2 + }, + { + "Type": 3 + }, + { + "Type": 4 + } + ] + ] + }, + [ + { + "Copy": { + "local": 1, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 3 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 8, + "projection": [] + } + ] + } + ] + }, + "span": 2 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 7, + "projection": [] + } + }, + 5 + ] + } + ] + }, + "span": 2 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 0, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 0, + "id": 0 + } + } + }, + "args": [ + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + }, + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 5, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 1 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 6 + }, + "span": 5 + }, + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 5, + "projection": [ + { + "Downcast": 0 + }, + { + "Field": [ + 0, + 6 + ] + } + ] + } + } + } + ] + }, + "span": 6 + }, + { + "kind": { + "StorageDead": 8 + }, + "span": 7 + }, + { + "kind": { + "StorageDead": 5 + }, + "span": 7 + } + ], + "terminator": { + "kind": "Return", + "span": 4 + } + } + ], + "locals": [ + { + "ty": 6, + "span": 8, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 9, + "mutability": "Not" + }, + { + "ty": 6, + "span": 10, + "mutability": "Not" + }, + { + "ty": 8, + "span": 11, + "mutability": "Not" + }, + { + "ty": 9, + "span": 12, + "mutability": "Not" + }, + { + "ty": 10, + "span": 1, + "mutability": "Mut" + }, + { + "ty": 5, + "span": 2, + "mutability": "Mut" + }, + { + "ty": 11, + "span": 2, + "mutability": "Not" + }, + { + "ty": 12, + "span": 3, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "main", + "source_info": { + "span": 9, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "argc", + "source_info": { + "span": 10, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "argv", + "source_info": { + "span": 11, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "sigpipe", + "source_info": { + "span": 12, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + }, + { + "name": "v", + "source_info": { + "span": 6, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 0, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 13 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17ha5dc080083b58409E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::rt::lang_start::<()>::{closure#0}", + "id": 1, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 2 + }, + "span": 16 + }, + { + "kind": { + "StorageLive": 3 + }, + "span": 15 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 17 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref", + { + "Field": [ + 0, + 7 + ] + } + ] + } + } + } + ] + }, + "span": 17 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 14, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 13, + "id": 1 + } + } + }, + "args": [ + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 3, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 15 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 4 + }, + "span": 19 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 18, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 14, + "id": 2 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 16 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 21 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 22 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [ + { + "Field": [ + 0, + 15 + ] + } + ] + } + ] + } + ] + }, + "span": 22 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 23 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + { + "Field": [ + 0, + 15 + ] + }, + { + "Field": [ + 0, + 9 + ] + } + ] + } + } + } + ] + }, + "span": 23 + }, + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Move": { + "local": 6, + "projection": [] + } + }, + 16 + ] + } + ] + }, + "span": 24 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 25 + }, + { + "kind": { + "StorageDead": 5 + }, + "span": 26 + }, + { + "kind": { + "StorageDead": 2 + }, + "span": 27 + } + ], + "terminator": { + "kind": "Return", + "span": 20 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 28, + "mutability": "Mut" + }, + { + "ty": 11, + "span": 3, + "mutability": "Mut" + }, + { + "ty": 17, + "span": 16, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 15, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 17, + "mutability": "Mut" + }, + { + "ty": 18, + "span": 22, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 23, + "mutability": "Mut" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "main", + "source_info": { + "span": 9, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [ + "Deref", + { + "Field": [ + 0, + 7 + ] + } + ] + } + }, + "argument_index": null + }, + { + "name": "self", + "source_info": { + "span": 29, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 30, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 5, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 3 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h9850ff6d26d0d49cE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::sys::backtrace::__rust_begin_short_backtrace::", + "id": 2, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 31, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 19, + "id": 3 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 33 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 34, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 20, + "id": 5 + } + } + }, + "args": [ + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 35 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 36 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 37, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 38, + "mutability": "Not" + }, + { + "ty": 1, + "span": 39, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "f", + "source_info": { + "span": 38, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "result", + "source_info": { + "span": 40, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 0, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "dummy", + "source_info": { + "span": 41, + "scope": 2 + }, + "composite": null, + "value": { + "Const": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 42 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17hd40535be7400a6f6E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 21, + "id": 6 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [ + "Deref" + ] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h2d22a339bbdd2052E", + "mono_item_kind": { + "MonoItemFn": { + "name": ">::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h34647d5ce086dc87E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 43 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 23, + "id": 7 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": { + "Cleanup": 3 + } + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 12, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + }, + { + "ty": 24, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h18fb8a505226337cE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", + "id": 4, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 44 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 44, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 44, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 44 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h1f8c021e0ac43527E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<() as std::process::Termination>::report", + "id": 5, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 46, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 17, + "id": 8 + } + } + } + } + ] + }, + "span": 46 + } + ], + "terminator": { + "kind": "Return", + "span": 45 + } + } + ], + "locals": [ + { + "ty": 17, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 48, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Const": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 49 + } + } + }, + "details": null + } + ], + "types": [ + [ + 1, + { + "TupleType": { + "types": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 2, + { + "PrimitiveType": { + "Int": "I8" + } + } + ], + [ + 5, + { + "RefType": { + "pointee_type": 42, + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 6, + { + "PrimitiveType": { + "Int": "Isize" + } + } + ], + [ + 8, + { + "PtrType": { + "pointee_type": 43, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 9, + { + "PrimitiveType": { + "Uint": "U8" + } + } + ], + [ + 10, + { + "EnumType": { + "name": "std::result::Result", + "adt_def": 27, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 6 + ], + [ + 36 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": true + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 11, + { + "RefType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 15, + { + "StructType": { + "name": "std::sys::pal::unix::process::process_common::ExitCode", + "adt_def": 19, + "fields": [ + 9 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 255 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 16, + { + "PrimitiveType": { + "Int": "I32" + } + } + ], + [ + 17, + { + "StructType": { + "name": "std::process::ExitCode", + "adt_def": 17, + "fields": [ + 15 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 255 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 18, + { + "RefType": { + "pointee_type": 15, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 22, + { + "PtrType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 24, + { + "RefType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 25, + { + "PtrType": { + "pointee_type": 28, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 26, + { + "PtrType": { + "pointee_type": 1, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 27, + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + 28, + { + "PrimitiveType": { + "Int": "I64" + } + } + ], + [ + 29, + { + "RefType": { + "pointee_type": 35, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 30, + { + "PtrType": { + "pointee_type": 35, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 31, + { + "PrimitiveType": "Bool" + } + ], + [ + 34, + { + "RefType": { + "pointee_type": 38, + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 35, + { + "StructType": { + "name": "Pair", + "adt_def": 8, + "fields": [ + 28, + 2 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": true + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": true + } + }, + "valid_range": { + "start": 0, + "end": 255 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 36, + "VoidType" + ], + [ + 37, + { + "RefType": { + "pointee_type": 39, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 38, + { + "PrimitiveType": "Str" + } + ], + [ + 39, + { + "StructType": { + "name": "std::panic::Location<'_>", + "adt_def": 12, + "fields": [ + 34, + 40, + 40 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 128 + }, + { + "num_bits": 160 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 192 + } + } + } + } + ], + [ + 40, + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + 43, + { + "PtrType": { + "pointee_type": 9, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ] + ], + "spans": [ + [ + 0, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 9, + 636, + 15 + ] + ], + [ + 24, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 9, + 636, + 22 + ] + ], + [ + 25, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 21, + 636, + 22 + ] + ], + [ + 26, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 635, + 19, + 635, + 24 + ] + ], + [ + 31, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 18, + 154, + 19 + ] + ], + [ + 32, + [ + "no-location", + 0, + 0, + 0, + 0 + ] + ], + [ + 33, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 18, + 154, + 21 + ] + ], + [ + 34, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 160, + 2, + 160, + 2 + ] + ], + [ + 38, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 150, + 43, + 150, + 44 + ] + ], + [ + 40, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 9, + 154, + 15 + ] + ], + [ + 41, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 150, + 1, + 160, + 2 + ] + ], + [ + 43, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", + 250, + 5, + 250, + 71 + ] + ], + [ + 44, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", + 521, + 1, + 521, + 56 + ] + ], + [ + 45, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 46, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 48, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 49, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 50, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 7, + 14, + 7, + 50 + ] + ], + [ + 51, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 7, + 16, + 7, + 20 + ] + ], + [ + 52, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 7, + 15, + 7, + 50 + ] + ], + [ + 53, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 8, + 2, + 8, + 2 + ] + ], + [ + 55, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 6, + 18, + 6, + 22 + ] + ], + [ + 57, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 6, + 1, + 8, + 2 + ] + ], + [ + 58, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 12, + 13, + 12, + 26 + ] + ], + [ + 59, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 12, + 13, + 12, + 33 + ] + ], + [ + 60, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 11, + 29, + 11, + 30 + ] + ], + [ + 61, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 11, + 38, + 11, + 39 + ] + ], + [ + 62, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 11, + 16, + 11, + 41 + ] + ], + [ + 63, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 12, + 27, + 12, + 32 + ] + ], + [ + 64, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 12, + 13, + 12, + 38 + ] + ], + [ + 65, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 13, + 2, + 13, + 2 + ] + ], + [ + 66, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 12, + 5, + 12, + 39 + ] + ], + [ + 68, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 11, + 9, + 11, + 13 + ] + ], + [ + 69, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", + 10, + 1, + 13, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state new file mode 100644 index 000000000..fdaad36b1 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state @@ -0,0 +1,50 @@ + + + #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K + + + noReturn + + + ty ( 32 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 2 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 1 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) + ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) + + \ No newline at end of file diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs new file mode 100644 index 000000000..a78147886 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs @@ -0,0 +1,14 @@ +use std::cell::UnsafeCell; + +fn read(cell: &UnsafeCell) -> i64 { + unsafe { + let raw: *const UnsafeCell = cell; + let inner: *const i64 = raw as *const i64; + *inner + } +} + +fn main() { + let cell = UnsafeCell::new(41); + assert!(read(&cell) == 41); +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json new file mode 100644 index 000000000..7bd6e5a12 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json @@ -0,0 +1,3763 @@ +{ + "name": "unsafe_cell_cast", + "crate_id": 17972866091748300451, + "allocs": [ + { + "alloc_id": 1, + "ty": 39, + "global_alloc": { + "Memory": { + "bytes": [ + 97, + 115, + 115, + 101, + 114, + 116, + 105, + 111, + 110, + 32, + 102, + 97, + 105, + 108, + 101, + 100, + 58, + 32, + 114, + 101, + 97, + 100, + 40, + 38, + 99, + 101, + 108, + 108, + 41, + 32, + 61, + 61, + 32, + 52, + 49 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Not" + } + } + } + ], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h61408a798a23843cE" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h76efa01750d221f7E" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17hb6e80083da3c9b59E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h47a589645b5b7a97E" + } + ], + [ + 23, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h74d64ac5485153d0E" + } + ], + [ + 33, + { + "NormalSym": "_ZN4core4cell19UnsafeCell$LT$T$GT$3new17hc140826c67c3f8f1E" + } + ], + [ + 34, + { + "NormalSym": "_ZN16unsafe_cell_cast4read17h7e34b1aad334a87dE" + } + ], + [ + 35, + { + "NormalSym": "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" + } + ], + [ + 42, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN16unsafe_cell_cast4main17h6e92912a3353492eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 9, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 64, + "user_ty": 0, + "const_": { + "kind": "ZeroSized", + "ty": 33, + "id": 11 + } + } + }, + "args": [ + { + "Constant": { + "span": 65, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 41, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 12 + } + } + } + ], + "destination": { + "local": 1, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 66 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 69 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 67, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 34, + "id": 13 + } + } + }, + "args": [ + { + "Copy": { + "local": 3, + "projection": [] + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 68 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 2, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 41, + 3 + ] + ], + "otherwise": 4 + } + } + }, + "span": 70 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 71 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 72, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 35, + "id": 14 + } + } + }, + "args": [ + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 35, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 0 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 36, + "id": 15 + } + } + } + ], + "destination": { + "local": 4, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 72 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 26, + "span": 74, + "mutability": "Not" + }, + { + "ty": 25, + "span": 68, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 69, + "mutability": "Not" + }, + { + "ty": 37, + "span": 72, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "cell", + "source_info": { + "span": 74, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 75 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16unsafe_cell_cast4read17h7e34b1aad334a87dE", + "mono_item_kind": { + "MonoItemFn": { + "name": "read", + "id": 8, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 1, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 56 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + 27 + ] + } + ] + }, + "span": 57 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 3, + "projection": [] + } + }, + 28 + ] + } + ] + }, + "span": 55 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + "Transmute", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + 29 + ] + } + ] + }, + "span": 55 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "NullaryOp": [ + "AlignOf", + 25 + ] + } + ] + }, + "span": 55 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Sub", + { + "Copy": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 29, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 55 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Copy": { + "local": 5, + "projection": [] + } + }, + { + "Copy": { + "local": 7, + "projection": [] + } + } + ] + } + ] + }, + "span": 55 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Copy": { + "local": 8, + "projection": [] + } + }, + { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 29, + "id": 10 + } + } + } + ] + } + ] + }, + "span": 55 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Copy": { + "local": 9, + "projection": [] + } + }, + "expected": true, + "msg": { + "MisalignedPointerDereference": { + "required": { + "Copy": { + "local": 6, + "projection": [] + } + }, + "found": { + "Copy": { + "local": 5, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Unreachable" + } + }, + "span": 55 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 3, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 55 + } + ], + "terminator": { + "kind": "Return", + "span": 58 + } + } + ], + "locals": [ + { + "ty": 25, + "span": 59, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 60, + "mutability": "Not" + }, + { + "ty": 31, + "span": 61, + "mutability": "Not" + }, + { + "ty": 27, + "span": 62, + "mutability": "Not" + }, + { + "ty": 28, + "span": 55, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 55, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 55, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 55, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 55, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 55, + "mutability": "Mut" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "cell", + "source_info": { + "span": 60, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "raw", + "source_info": { + "span": 61, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "inner", + "source_info": { + "span": 62, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 63 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17hb3f3726bf09716b2E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::rt::lang_start::<()>", + "id": 0, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 1 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 2 + }, + { + "kind": { + "StorageLive": 8 + }, + "span": 3 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + { + "Closure": [ + 1, + [ + { + "Type": 1 + }, + { + "Type": 2 + }, + { + "Type": 3 + }, + { + "Type": 4 + } + ] + ] + }, + [ + { + "Copy": { + "local": 1, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 3 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 8, + "projection": [] + } + ] + } + ] + }, + "span": 2 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 7, + "projection": [] + } + }, + 5 + ] + } + ] + }, + "span": 2 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 0, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 0, + "id": 0 + } + } + }, + "args": [ + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + }, + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 5, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 1 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 6 + }, + "span": 5 + }, + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 5, + "projection": [ + { + "Downcast": 0 + }, + { + "Field": [ + 0, + 6 + ] + } + ] + } + } + } + ] + }, + "span": 6 + }, + { + "kind": { + "StorageDead": 8 + }, + "span": 7 + }, + { + "kind": { + "StorageDead": 5 + }, + "span": 7 + } + ], + "terminator": { + "kind": "Return", + "span": 4 + } + } + ], + "locals": [ + { + "ty": 6, + "span": 8, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 9, + "mutability": "Not" + }, + { + "ty": 6, + "span": 10, + "mutability": "Not" + }, + { + "ty": 8, + "span": 11, + "mutability": "Not" + }, + { + "ty": 9, + "span": 12, + "mutability": "Not" + }, + { + "ty": 10, + "span": 1, + "mutability": "Mut" + }, + { + "ty": 5, + "span": 2, + "mutability": "Mut" + }, + { + "ty": 11, + "span": 2, + "mutability": "Not" + }, + { + "ty": 12, + "span": 3, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "main", + "source_info": { + "span": 9, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "argc", + "source_info": { + "span": 10, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "argv", + "source_info": { + "span": 11, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "sigpipe", + "source_info": { + "span": 12, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + }, + { + "name": "v", + "source_info": { + "span": 6, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 0, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 13 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h74d64ac5485153d0E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::rt::lang_start::<()>::{closure#0}", + "id": 1, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 2 + }, + "span": 16 + }, + { + "kind": { + "StorageLive": 3 + }, + "span": 15 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 17 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref", + { + "Field": [ + 0, + 7 + ] + } + ] + } + } + } + ] + }, + "span": 17 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 14, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 13, + "id": 1 + } + } + }, + "args": [ + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 3, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 15 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 4 + }, + "span": 19 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 18, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 14, + "id": 2 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 16 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 21 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 22 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [ + { + "Field": [ + 0, + 15 + ] + } + ] + } + ] + } + ] + }, + "span": 22 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 23 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + { + "Field": [ + 0, + 15 + ] + }, + { + "Field": [ + 0, + 9 + ] + } + ] + } + } + } + ] + }, + "span": 23 + }, + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Move": { + "local": 6, + "projection": [] + } + }, + 16 + ] + } + ] + }, + "span": 24 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 25 + }, + { + "kind": { + "StorageDead": 5 + }, + "span": 26 + }, + { + "kind": { + "StorageDead": 2 + }, + "span": 27 + } + ], + "terminator": { + "kind": "Return", + "span": 20 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 28, + "mutability": "Mut" + }, + { + "ty": 11, + "span": 3, + "mutability": "Mut" + }, + { + "ty": 17, + "span": 16, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 15, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 17, + "mutability": "Mut" + }, + { + "ty": 18, + "span": 22, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 23, + "mutability": "Mut" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "main", + "source_info": { + "span": 9, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [ + "Deref", + { + "Field": [ + 0, + 7 + ] + } + ] + } + }, + "argument_index": null + }, + { + "name": "self", + "source_info": { + "span": 29, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 30, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 5, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 3 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h61408a798a23843cE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::sys::backtrace::__rust_begin_short_backtrace::", + "id": 2, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 31, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 19, + "id": 3 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 33 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 34, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 20, + "id": 5 + } + } + }, + "args": [ + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 35 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 36 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 37, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 38, + "mutability": "Not" + }, + { + "ty": 1, + "span": 39, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "f", + "source_info": { + "span": 38, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "result", + "source_info": { + "span": 40, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 0, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "dummy", + "source_info": { + "span": 41, + "scope": 2 + }, + "composite": null, + "value": { + "Const": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 42 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h95156b73cd583802E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 21, + "id": 6 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [ + "Deref" + ] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h47a589645b5b7a97E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 43 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 23, + "id": 7 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": { + "Cleanup": 3 + } + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 12, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + }, + { + "ty": 24, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17hb6e80083da3c9b59E", + "mono_item_kind": { + "MonoItemFn": { + "name": ">::call_once", + "id": 3, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 43 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 43, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 43, + "mutability": "Not" + }, + { + "ty": 1, + "span": 43, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 43 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h5fbb76094b60164eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", + "id": 4, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 44 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 44, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 44, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 44 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core4cell19UnsafeCell$LT$T$GT$3new17hc140826c67c3f8f1E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::cell::UnsafeCell::::new", + "id": 5, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 6, + 0, + [ + { + "Type": 25 + } + ], + null, + null + ] + }, + [ + { + "Copy": { + "local": 1, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 46 + } + ], + "terminator": { + "kind": "Return", + "span": 45 + } + } + ], + "locals": [ + { + "ty": 26, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 48, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "value", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 49 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h76efa01750d221f7E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<() as std::process::Termination>::report", + "id": 7, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 51, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 17, + "id": 8 + } + } + } + } + ] + }, + "span": 51 + } + ], + "terminator": { + "kind": "Return", + "span": 50 + } + } + ], + "locals": [ + { + "ty": 17, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 53, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 53, + "scope": 0 + }, + "composite": null, + "value": { + "Const": { + "span": 32, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 1, + "id": 4 + } + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 54 + } + } + }, + "details": null + } + ], + "types": [ + [ + 1, + { + "TupleType": { + "types": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 5, + { + "RefType": { + "pointee_type": 43, + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 6, + { + "PrimitiveType": { + "Int": "Isize" + } + } + ], + [ + 8, + { + "PtrType": { + "pointee_type": 44, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 9, + { + "PrimitiveType": { + "Uint": "U8" + } + } + ], + [ + 10, + { + "EnumType": { + "name": "std::result::Result", + "adt_def": 22, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 6 + ], + [ + 37 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": true + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 11, + { + "RefType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 15, + { + "StructType": { + "name": "std::sys::pal::unix::process::process_common::ExitCode", + "adt_def": 28, + "fields": [ + 9 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 255 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 16, + { + "PrimitiveType": { + "Int": "I32" + } + } + ], + [ + 17, + { + "StructType": { + "name": "std::process::ExitCode", + "adt_def": 26, + "fields": [ + 15 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 255 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 18, + { + "RefType": { + "pointee_type": 15, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 22, + { + "PtrType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 24, + { + "RefType": { + "pointee_type": 12, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 25, + { + "PrimitiveType": { + "Int": "I64" + } + } + ], + [ + 26, + { + "StructType": { + "name": "std::cell::UnsafeCell", + "adt_def": 6, + "fields": [ + 25 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": true + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 27, + { + "PtrType": { + "pointee_type": 25, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 28, + { + "PtrType": { + "pointee_type": 1, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 29, + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + 30, + { + "RefType": { + "pointee_type": 26, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 31, + { + "PtrType": { + "pointee_type": 26, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 32, + { + "PrimitiveType": "Bool" + } + ], + [ + 36, + { + "RefType": { + "pointee_type": 39, + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 37, + "VoidType" + ], + [ + 38, + { + "RefType": { + "pointee_type": 40, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 39, + { + "PrimitiveType": "Str" + } + ], + [ + 40, + { + "StructType": { + "name": "std::panic::Location<'_>", + "adt_def": 12, + "fields": [ + 36, + 41, + 41 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 128 + }, + { + "num_bits": 160 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 192 + } + } + } + } + ], + [ + 41, + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + 44, + { + "PtrType": { + "pointee_type": 9, + "layout": { + "fields": "Primitive", + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ] + ], + "spans": [ + [ + 0, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 9, + 636, + 15 + ] + ], + [ + 24, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 9, + 636, + 22 + ] + ], + [ + 25, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 636, + 21, + 636, + 22 + ] + ], + [ + 26, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", + 635, + 19, + 635, + 24 + ] + ], + [ + 31, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 18, + 154, + 19 + ] + ], + [ + 32, + [ + "no-location", + 0, + 0, + 0, + 0 + ] + ], + [ + 33, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 18, + 154, + 21 + ] + ], + [ + 34, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 160, + 2, + 160, + 2 + ] + ], + [ + 38, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 150, + 43, + 150, + 44 + ] + ], + [ + 40, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 154, + 9, + 154, + 15 + ] + ], + [ + 41, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", + 150, + 1, + 160, + 2 + ] + ], + [ + 43, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", + 250, + 5, + 250, + 71 + ] + ], + [ + 44, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", + 521, + 1, + 521, + 56 + ] + ], + [ + 45, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", + 2099, + 6, + 2099, + 6 + ] + ], + [ + 46, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", + 2098, + 9, + 2098, + 29 + ] + ], + [ + 48, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", + 2097, + 22, + 2097, + 27 + ] + ], + [ + 49, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", + 2097, + 5, + 2099, + 6 + ] + ], + [ + 50, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 51, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 53, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 54, + [ + "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 55, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 7, + 9, + 7, + 15 + ] + ], + [ + 56, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 5, + 43, + 5, + 47 + ] + ], + [ + 57, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 6, + 33, + 6, + 50 + ] + ], + [ + 58, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 9, + 2, + 9, + 2 + ] + ], + [ + 60, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 3, + 9, + 3, + 13 + ] + ], + [ + 61, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 5, + 13, + 5, + 16 + ] + ], + [ + 62, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 6, + 13, + 6, + 18 + ] + ], + [ + 63, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 3, + 1, + 9, + 2 + ] + ], + [ + 64, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 12, + 16, + 12, + 31 + ] + ], + [ + 65, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 12, + 32, + 12, + 34 + ] + ], + [ + 66, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 12, + 16, + 12, + 35 + ] + ], + [ + 67, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 13, + 13, + 13, + 17 + ] + ], + [ + 68, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 13, + 13, + 13, + 24 + ] + ], + [ + 69, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 13, + 18, + 13, + 23 + ] + ], + [ + 70, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 13, + 13, + 13, + 30 + ] + ], + [ + 71, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 14, + 2, + 14, + 2 + ] + ], + [ + 72, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 13, + 5, + 13, + 31 + ] + ], + [ + 74, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 12, + 9, + 12, + 13 + ] + ], + [ + 75, + [ + "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", + 11, + 1, + 14, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state new file mode 100644 index 000000000..8ec262fc3 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state @@ -0,0 +1,49 @@ + + + #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K + + + noReturn + + + ty ( 34 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 56 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 57 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 28 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 29 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 25 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 55 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 55 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 3 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 55 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 58 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 2 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 2 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 31 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 27 ) , mutabilityNot ) ) + ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , ty ( 29 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 29 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 29 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 29 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 32 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 41 , 64 , true ) ) ) , ty ( 26 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 37 ) , mutabilityMut ) ) ) ) + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) + + \ No newline at end of file diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index a42265cc9..b88ac9023 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -262,6 +262,18 @@ def test_crate_examples(main_crate: Path, kmir: KMIR, update_expected_output: bo EXEC_DATA_DIR / 'pointers' / 'ref_ptr_cases.state', 1000, ), + ( + 'struct_cast_fail', + EXEC_DATA_DIR / 'pointers' / 'struct_cast_fail.smir.json', + EXEC_DATA_DIR / 'pointers' / 'struct_cast_fail.state', + 1000, + ), + ( + 'unsafe_cell_cast', + EXEC_DATA_DIR / 'pointers' / 'unsafe_cell_cast.smir.json', + EXEC_DATA_DIR / 'pointers' / 'unsafe_cell_cast.state', + 1000, + ), ( 'Ref-array-elem-ref', EXEC_DATA_DIR / 'references' / 'array_elem_ref.smir.json', From c2d6862784a407f142e81b3e945c457a0532946f Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 17:38:17 +0800 Subject: [PATCH 03/66] chore: update state without thunk and any modification --- .../exec-smir/pointers/unsafe_cell_cast.state | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state index 8ec262fc3..c449156cc 100644 --- a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state +++ b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state @@ -1,6 +1,6 @@ - #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K + #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 31 ) , ty ( 27 ) ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ~> .K ) ~> #execStmts ( statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 28 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 29 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 25 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 55 ) ) .Statements ) ~> #execTerminator ( terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 55 ) ) ) ~> .K noReturn @@ -29,13 +29,13 @@ ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 31 ) , mutabilityNot ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 27 ) , mutabilityNot ) ) - ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , ty ( 29 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 29 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 29 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 29 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 27 ) , ty ( 28 ) ) ) , castKindTransmute , ty ( 28 ) , ty ( 29 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 32 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 27 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 32 ) , mutabilityMut ) ) From 28cf9d59bab42c3ebaf275af84784015980bfce2 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 21:56:11 +0800 Subject: [PATCH 04/66] feat: support UnsafeCell cast to Int --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 43 ++++++++++++++++- .../kmir/kdist/mir-semantics/rt/decoding.md | 6 --- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 48 +++++++++++++++++++ .../exec-smir/pointers/unsafe_cell_cast.state | 35 ++++++-------- 4 files changed, 104 insertions(+), 28 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 7adc8dd0f..7d56cf684 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1265,12 +1265,37 @@ which have the same representation `Value::Range`. ```k rule #cast(PtrLocal(OFFSET, PLACE, MUT, META), castKindPtrToPtr, TY_SOURCE, TY_TARGET) => - PtrLocal(OFFSET, PLACE, MUT, #convertMetadata(META, lookupTy(TY_TARGET))) + PtrLocal( + OFFSET, + #alignTransparentPlace( + PLACE, + #lookupMaybeTy(pointeeTy(lookupTy(TY_SOURCE))), + #lookupMaybeTy(pointeeTy(lookupTy(TY_TARGET))) + ), + MUT, + #convertMetadata(META, lookupTy(TY_TARGET)) + ) ... requires #typesCompatible(lookupTy(TY_SOURCE), lookupTy(TY_TARGET)) [preserves-definedness] // valid map lookups checked + syntax Place ::= #alignTransparentPlace ( Place , TypeInfo , TypeInfo ) [function, total] + + rule #alignTransparentPlace(place(LOCAL, PROJS), typeInfoStructType(_, _, FIELD_TY .Tys, LAYOUT) #as SOURCE, TARGET) + => #alignTransparentPlace( + place( + LOCAL, + appendP(PROJS, projectionElemField(fieldIdx(0), FIELD_TY) .ProjectionElems) + ), + lookupTy(FIELD_TY), + TARGET + ) + requires #transparentDepth(SOURCE) >Int #transparentDepth(TARGET) + andBool #zeroFieldOffset(LAYOUT) + + rule #alignTransparentPlace(PLACE, _, _) => PLACE [owise] + syntax Metadata ::= #convertMetadata ( Metadata , TypeInfo ) [function, total] // ------------------------------------------------------------------------------------- ``` @@ -1388,6 +1413,22 @@ What can be supported without additional layout consideration is trivial casts b rule #cast(PtrLocal(_, _, _, _) #as PTR, castKindTransmute, TY_SOURCE, TY_TARGET) => PTR ... requires lookupTy(TY_SOURCE) ==K lookupTy(TY_TARGET) + + rule #cast( + PtrLocal(_, _, _, metadata(_, PTR_OFFSET, _)), + castKindTransmute, + _TY_SOURCE, + TY_TARGET + ) + => + #intAsType( + PTR_OFFSET, + #bitWidth(#numTypeOf(lookupTy(TY_TARGET))), + #numTypeOf(lookupTy(TY_TARGET)) + ) + ... + + requires #isIntType(lookupTy(TY_TARGET)) ``` Other `Transmute` casts that can be resolved are round-trip casts from type A to type B and then directly back from B to A. diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/decoding.md b/kmir/src/kmir/kdist/mir-semantics/rt/decoding.md index 77cc5bbd5..c98f56a9a 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/decoding.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/decoding.md @@ -100,12 +100,6 @@ syntax Int ::= #msBytes ( MachineSize ) [function, total] rule #msBytes(machineSize(mirInt(NBITS))) => NBITS /Int 8 [preserves-definedness] rule #msBytes(machineSize(NBITS)) => NBITS /Int 8 [owise, preserves-definedness] -// Extract field offsets from the struct layout when available (Arbitrary only). -syntax MachineSizes ::= #structOffsets ( MaybeLayoutShape ) [function, total] -rule #structOffsets(someLayoutShape(layoutShape(fieldsShapeArbitrary(mk(OFFSETS)), _, _, _, _))) => OFFSETS -rule #structOffsets(noLayoutShape) => .MachineSizes -rule #structOffsets(_) => .MachineSizes [owise] - // Minimum number of input bytes required to decode all fields by the chosen offsets. // Uses builtin maxInt to compute max(offset + size). The lists of types and // offsets must have the same length; if not, this function returns -1 to signal diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index b46ce90ff..49946d667 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -8,6 +8,7 @@ requires "value.md" module RT-TYPES imports BOOL + imports INT imports MAP imports K-EQUAL @@ -59,6 +60,35 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #isArrayOf(typeInfoArrayType(TY, _), TY) => true rule #isArrayOf( _ , _ ) => false [owise] + + rule #typesCompatible(SRC, OTHER) => true + requires #zeroSizedType(SRC) orBool #zeroSizedType(OTHER) + + syntax Bool ::= #zeroSizedType ( TypeInfo ) [function, total] + + rule #zeroSizedType(typeInfoTupleType(.Tys)) => true + rule #zeroSizedType(typeInfoStructType(_, _, .Tys, _)) => true + rule #zeroSizedType(_) => false [owise] + + rule #typesCompatible(typeInfoStructType(_, _, FIELD .Tys, LAYOUT), OTHER) + => #typesCompatible(lookupTy(FIELD), OTHER) + requires #zeroFieldOffset(LAYOUT) + + rule #typesCompatible(OTHER, typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) + => #typesCompatible(OTHER, lookupTy(FIELD)) + requires #zeroFieldOffset(LAYOUT) + + syntax Bool ::= #zeroFieldOffset ( MaybeLayoutShape ) [function, total] + + rule #zeroFieldOffset(LAYOUT) + => #structOffsets(LAYOUT) ==K .MachineSizes + orBool #structOffsets(LAYOUT) ==K machineSize(mirInt(0)) .MachineSizes + orBool #structOffsets(LAYOUT) ==K machineSize(0) .MachineSizes + + syntax MachineSizes ::= #structOffsets ( MaybeLayoutShape ) [function, total] + + rule #structOffsets(someLayoutShape(layoutShape(fieldsShapeArbitrary(mk(OFFSETS)), _, _, _, _))) => OFFSETS + rule #structOffsets(_) => .MachineSizes [owise] ``` ## Determining types of places with projection @@ -70,6 +100,24 @@ To make this function total, an optional `MaybeTy` is used. syntax MaybeTy ::= Ty | "TyUnknown" + syntax MaybeTy ::= #transparentFieldTy ( TypeInfo ) [function, total] + + rule #transparentFieldTy(typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) => FIELD + requires #zeroFieldOffset(LAYOUT) + rule #transparentFieldTy(_) => TyUnknown [owise] + + syntax Int ::= #transparentDepth ( TypeInfo ) [function, total] + + rule #transparentDepth(typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) + => 1 +Int #transparentDepth(lookupTy(FIELD)) + requires #zeroFieldOffset(LAYOUT) + rule #transparentDepth(_) => 0 [owise] + + syntax TypeInfo ::= #lookupMaybeTy ( MaybeTy ) [function, total] + + rule #lookupMaybeTy(TY:Ty) => lookupTy(TY) + rule #lookupMaybeTy(TyUnknown) => typeInfoVoidType + syntax MaybeTy ::= getTyOf( MaybeTy , ProjectionElems ) [function, total] // ----------------------------------------------------------- rule getTyOf(TyUnknown, _ ) => TyUnknown diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state index c449156cc..0f712290e 100644 --- a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state +++ b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state @@ -1,49 +1,42 @@ - #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 31 ) , ty ( 27 ) ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ~> .K ) ~> #execStmts ( statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 28 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 29 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 25 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 55 ) ) .Statements ) ~> #execTerminator ( terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 55 ) ) ) ~> .K + #EndProgram ~> .K noReturn - ty ( 34 ) + ty ( -1 ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 56 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 57 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 28 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 29 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 25 ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 55 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 29 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 55 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 55 ) ) ) ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 3 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 55 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 58 ) ) ) ) + ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 64 ) , userTy: someUserTypeAnnotationIndex ( userTypeAnnotationIndex ( 0 ) ) , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 33 ) , id: mirConstId ( 11 ) ) ) ) , args: operandConstant ( constOperand (... span: span ( 65 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b")\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 25 ) , id: mirConstId ( 12 ) ) ) ) .Operands , destination: place (... local: local ( 1 ) , projection: .ProjectionElems ) , target: someBasicBlockIdx ( basicBlockIdx ( 1 ) ) , unwind: unwindActionContinue ) , span: span ( 66 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 1 ) , projection: .ProjectionElems ) ) ) , span: span ( 69 ) ) .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 67 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 34 ) , id: mirConstId ( 13 ) ) ) ) , args: operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) .Operands , destination: place (... local: local ( 2 ) , projection: .ProjectionElems ) , target: someBasicBlockIdx ( basicBlockIdx ( 2 ) ) , unwind: unwindActionContinue ) , span: span ( 68 ) ) ) ) + ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindSwitchInt (... discr: operandMove ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , targets: switchTargets (... branches: branch ( 41 , basicBlockIdx ( 3 ) ) .Branches , otherwise: basicBlockIdx ( 4 ) ) ) , span: span ( 70 ) ) ) ) + ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 71 ) ) ) ) + ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 72 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 35 ) , id: mirConstId ( 14 ) ) ) ) , args: operandConstant ( constOperand (... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: provenanceMapEntry (... offset: 0 , allocId: allocId ( 0 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 36 ) , id: mirConstId ( 15 ) ) ) ) .Operands , destination: place (... local: local ( 4 ) , projection: .ProjectionElems ) , target: noBasicBlockIdx , unwind: unwindActionContinue ) , span: span ( 72 ) ) ) ) ty ( -1 ) - place (... local: local ( 2 ) , projection: .ProjectionElems ) + place (... local: local ( 0 ) , projection: .ProjectionElems ) - someBasicBlockIdx ( basicBlockIdx ( 2 ) ) + noBasicBlockIdx unwindActionContinue - ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 31 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 27 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) - ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) - ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) - ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) - ListItem ( newLocal ( ty ( 32 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 41 , 64 , true ) ) ) , ty ( 26 ) , mutabilityNot ) ) + ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 37 ) , mutabilityMut ) ) - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) - ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 41 , 64 , true ) ) ) , ty ( 26 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 37 ) , mutabilityMut ) ) ) ) ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) \ No newline at end of file From 93cad6f18a6d7aecde8316a2a93a0f2910ae76f1 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 22:07:59 +0800 Subject: [PATCH 05/66] chore: new passed prove-rs/local-raw-fail.rs test --- .../data/prove-rs/{local-raw-fail.rs => local-raw.rs} | 0 kmir/src/tests/integration/test_integration.py | 2 -- 2 files changed, 2 deletions(-) rename kmir/src/tests/integration/data/prove-rs/{local-raw-fail.rs => local-raw.rs} (100%) diff --git a/kmir/src/tests/integration/data/prove-rs/local-raw-fail.rs b/kmir/src/tests/integration/data/prove-rs/local-raw.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/local-raw-fail.rs rename to kmir/src/tests/integration/data/prove-rs/local-raw.rs diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index b88ac9023..3056ad1c4 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -38,7 +38,6 @@ 'assume-cheatcode-conflict-fail': ['check_assume_conflict'], } PROVE_RS_SHOW_SPECS = [ - 'local-raw-fail', 'interior-mut-fail', 'interior-mut2-fail', 'interior-mut3-fail', @@ -54,7 +53,6 @@ 'assume-cheatcode-conflict-fail', ] - @pytest.mark.parametrize( 'rs_file', PROVE_RS_FILES, From fa24d9b496b7d3fb021583818bfc5798e3464679 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 22:41:29 +0800 Subject: [PATCH 06/66] fix: closure_access_struct failure --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 22 +++++++++---------- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 1 + .../show/closure_access_struct.main.expected | 17 -------------- .../src/tests/integration/test_integration.py | 1 - 4 files changed, 12 insertions(+), 29 deletions(-) delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/closure_access_struct.main.expected diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 7d56cf684..06801bdbe 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -439,17 +439,6 @@ This is done without consideration of the validity of the Downcast[^downcast]. If an Aggregate contains only one element and #traverseProjection becomes stuck, you can directly access this element. -Without this rule, the test `closure_access_struct-fail.rs` demonstrates the following behavior: -- The execution gets stuck after 192 steps at `#traverseProjection ( toLocal ( 2 ) , Aggregate ( variantIdx ( 0 ) , ListItem ( ... ) ) , ... )` -- The stuck state occurs because there's a Deref projection that needs to be applied to the single element of this Aggregate, but the existing Deref rules only handle pointers and references, not Aggregates - -With this rule enabled: -- The execution progresses further to 277 steps before getting stuck -- It gets stuck at a different location: `#traverseProjection ( toLocal ( 19 ) , thunk ( #decodeConstant ( constantKindAll ... ) ) , ... )` -- The rule automatically unwraps the single-element Aggregate, allowing the field access to proceed - -This rule is essential for handling closures that access struct fields, as MIR represents certain struct accesses through single-element Aggregates that need to be unwrapped. - ```k rule #traverseProjection( DEST, @@ -1080,6 +1069,17 @@ This eliminates any `Deref` projections from the place, and also resolves `Index // rule #projectionsFor(CtxPointerOffset(OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, projectionElemSubslice(OFFSET, ORIGIN_LENGTH, false) PROJS) rule #projectionsFor(CtxPointerOffset( _, OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, PointerOffset(OFFSET, ORIGIN_LENGTH) PROJS) + rule rvalueRef(_REGION, KIND, place(local(I), PROJS)) + => #traverseProjection(toLocal(I), Aggregate(variantIdx(0), .List), PROJS, .Contexts) + ~> #forRef(#mutabilityOf(KIND), metadata(noMetadataSize, 0, noMetadataSize)) + ... + + LOCALS + requires 0 <=Int I andBool I rvalueRef(_REGION, KIND, place(local(I), PROJS)) => #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) ~> #forRef(#mutabilityOf(KIND), metadata(#metadataSize(tyOfLocal({LOCALS[I]}:>TypedLocal), PROJS), 0, noMetadataSize)) // TODO: Sus on this rule diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 49946d667..fa7b3522b 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -68,6 +68,7 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #zeroSizedType(typeInfoTupleType(.Tys)) => true rule #zeroSizedType(typeInfoStructType(_, _, .Tys, _)) => true + rule #zeroSizedType(typeInfoVoidType) => true rule #zeroSizedType(_) => false [owise] rule #typesCompatible(typeInfoStructType(_, _, FIELD .Tys, LAYOUT), OTHER) diff --git a/kmir/src/tests/integration/data/prove-rs/show/closure_access_struct.main.expected b/kmir/src/tests/integration/data/prove-rs/show/closure_access_struct.main.expected deleted file mode 100644 index 0459ee731..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/closure_access_struct.main.expected +++ /dev/null @@ -1,17 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (315 steps) -├─ 3 (terminal) -│ #EndProgram ~> .K -│ function: main -│ -┊ constraint: true -┊ subst: ... -└─ 2 (leaf, target, terminal) - #EndProgram ~> .K - - - diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index 3056ad1c4..1fcbf03bf 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -48,7 +48,6 @@ 'checked_arithmetic-fail', 'offset-u8-fail', 'pointer-cast-length-test-fail', - 'closure_access_struct', 'niche-enum', 'assume-cheatcode-conflict-fail', ] From ede664c9dd4753692a055140bca037b42f0b6f84 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 22:51:30 +0800 Subject: [PATCH 07/66] chore: make format --- kmir/src/tests/integration/test_integration.py | 1 + 1 file changed, 1 insertion(+) diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index 1fcbf03bf..4d4154ac3 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -52,6 +52,7 @@ 'assume-cheatcode-conflict-fail', ] + @pytest.mark.parametrize( 'rs_file', PROVE_RS_FILES, From 55237eb79cf4364fe23ce5b0e1c77b5d1b51a232 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 22:55:42 +0800 Subject: [PATCH 08/66] chore: remove passed test expected --- .../show/local-raw-fail.main.expected | 40 ------------------- 1 file changed, 40 deletions(-) delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/local-raw-fail.main.expected diff --git a/kmir/src/tests/integration/data/prove-rs/show/local-raw-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/local-raw-fail.main.expected deleted file mode 100644 index a99c05167..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/local-raw-fail.main.expected +++ /dev/null @@ -1,40 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (105 steps) -├─ 3 -│ #expect ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , th -│ function: main -┃ -┃ (1 step) -┣━━┓ -┃ │ -┃ ├─ 4 -┃ │ AssertError ( assertMessageMisalignedPointerDereference ( ... required: operandC -┃ │ function: main -┃ │ -┃ │ (1 step) -┃ └─ 6 (stuck, leaf) -┃ #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference ( ... re -┃ function: main -┃ -┗━━┓ - │ - ├─ 5 - │ #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K - │ function: main - │ - │ (16 steps) - ├─ 7 (terminal) - │ #EndProgram ~> .K - │ function: main - │ - ┊ constraint: true - ┊ subst: ... - └─ 2 (leaf, target, terminal) - #EndProgram ~> .K - - - From 21f5034dd2845d9e6fb96a7567aa0418af9a180d Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 23:18:05 +0800 Subject: [PATCH 09/66] chore: update expected state --- .../exec-smir/pointers/struct_cast_fail.state | 149 ++++++++++++------ 1 file changed, 100 insertions(+), 49 deletions(-) diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state index fdaad36b1..cd9c167f9 100644 --- a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state +++ b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state @@ -1,50 +1,101 @@ - - - #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K - - - noReturn - - - ty ( 32 ) - - - - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) - - - ty ( -1 ) - - - place (... local: local ( 2 ) , projection: .ProjectionElems ) - - - someBasicBlockIdx ( basicBlockIdx ( 1 ) ) - - - unwindActionContinue - - + + + #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K + + + noReturn + + + ty ( 32 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 2 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 1 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) + ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) - - - - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) - ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) - ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) - - \ No newline at end of file + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) + + +#Or + + + #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , projectionElemDeref .ProjectionElems , .Contexts ) ~> #readProjection ( false ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 0 ) , projection: .ProjectionElems ) ~> .K ) ~> #execStmts ( .Statements ) ~> #execTerminator ( terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ~> .K + + + noReturn + + + ty ( 32 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 2 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 1 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) + ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) + ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) + + \ No newline at end of file From 537b5843281f76533f437103401e305f1a5ad939 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 23:23:50 +0800 Subject: [PATCH 10/66] chore: update test pass status --- .../{interior-mut2-fail.rs => interior-mut2.rs} | 0 .../show/interior-mut2-fail.main.expected | 15 --------------- kmir/src/tests/integration/test_integration.py | 1 - 3 files changed, 16 deletions(-) rename kmir/src/tests/integration/data/prove-rs/{interior-mut2-fail.rs => interior-mut2.rs} (100%) delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/interior-mut2-fail.main.expected diff --git a/kmir/src/tests/integration/data/prove-rs/interior-mut2-fail.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut2.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/interior-mut2-fail.rs rename to kmir/src/tests/integration/data/prove-rs/interior-mut2.rs diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut2-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut2-fail.main.expected deleted file mode 100644 index 6ef3112a7..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut2-fail.main.expected +++ /dev/null @@ -1,15 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (185 steps) -└─ 3 (stuck, leaf) - #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 3 , place ( ... - span: 53 - - -┌─ 2 (root, leaf, target, terminal) -│ #EndProgram ~> .K - - diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index 4d4154ac3..0357f000d 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -39,7 +39,6 @@ } PROVE_RS_SHOW_SPECS = [ 'interior-mut-fail', - 'interior-mut2-fail', 'interior-mut3-fail', 'assert_eq_exp', 'bitwise-not-shift', From c5252187b4eda106cde29adffb8fb753fbbe6cf7 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 30 Oct 2025 23:36:22 +0800 Subject: [PATCH 11/66] chore: update test pass status --- .../data/prove-rs/show/interior-mut-fail.main.expected | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected index 7cb6831b6..07ddc99a8 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected @@ -3,10 +3,10 @@ │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ span: 0 │ -│ (198 steps) +│ (866 steps) └─ 3 (stuck, leaf) - #traverseProjection ( toLocal ( 11 ) , thunk ( #cast ( PtrLocal ( 3 , place ( .. - span: 91 + #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , + span: 32 ┌─ 2 (root, leaf, target, terminal) From f270fe8fef6feba4724c852fca5a38aeaa69e8c6 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 31 Oct 2025 09:23:47 +0800 Subject: [PATCH 12/66] chore: add more test for the semantics --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 1 + .../pointers/struct_cast_fail.smir.json | 3632 ---------------- .../exec-smir/pointers/struct_cast_fail.state | 101 - .../pointers/unsafe_cell_cast.smir.json | 3763 ----------------- .../exec-smir/pointers/unsafe_cell_cast.state | 42 - ...efcell.rs => interior-mut-refcell-fail.rs} | 0 .../pointer-cast-struct-field-fail.rs} | 0 .../pointer-cast-transparent-wrapper.rs | 21 + .../pointer-cast-unsafe-cell.rs} | 0 .../data/prove-rs/reference-zero-sized.rs | 7 + .../interior-mut-refcell-fail.main.expected | 15 + ...inter-cast-struct-field-fail.main.expected | 40 + .../src/tests/integration/test_integration.py | 14 +- 13 files changed, 86 insertions(+), 7550 deletions(-) delete mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json delete mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state delete mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json delete mode 100644 kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state rename kmir/src/tests/integration/data/prove-rs/{refcell.rs => interior-mut-refcell-fail.rs} (100%) rename kmir/src/tests/integration/data/{exec-smir/pointers/struct_cast_fail.rs => prove-rs/pointer-cast-struct-field-fail.rs} (100%) create mode 100644 kmir/src/tests/integration/data/prove-rs/pointer-cast-transparent-wrapper.rs rename kmir/src/tests/integration/data/{exec-smir/pointers/unsafe_cell_cast.rs => prove-rs/pointer-cast-unsafe-cell.rs} (100%) create mode 100644 kmir/src/tests/integration/data/prove-rs/reference-zero-sized.rs create mode 100644 kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected create mode 100644 kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 06801bdbe..80b2201c5 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1069,6 +1069,7 @@ This eliminates any `Deref` projections from the place, and also resolves `Index // rule #projectionsFor(CtxPointerOffset(OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, projectionElemSubslice(OFFSET, ORIGIN_LENGTH, false) PROJS) rule #projectionsFor(CtxPointerOffset( _, OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, PointerOffset(OFFSET, ORIGIN_LENGTH) PROJS) + // Borrowing a zero-sized local that is still `NewLocal`: materialise a dummy ZST value so projection traversal succeeds without reading uninitialised data. rule rvalueRef(_REGION, KIND, place(local(I), PROJS)) => #traverseProjection(toLocal(I), Aggregate(variantIdx(0), .List), PROJS, .Contexts) ~> #forRef(#mutabilityOf(KIND), metadata(noMetadataSize, 0, noMetadataSize)) diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json deleted file mode 100644 index 2df1fb4bc..000000000 --- a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.smir.json +++ /dev/null @@ -1,3632 +0,0 @@ -{ - "name": "struct_cast_fail", - "crate_id": 4745107763802994174, - "allocs": [ - { - "alloc_id": 1, - "ty": 38, - "global_alloc": { - "Memory": { - "bytes": [ - 97, - 115, - 115, - 101, - 114, - 116, - 105, - 111, - 110, - 32, - 102, - 97, - 105, - 108, - 101, - 100, - 58, - 32, - 114, - 101, - 97, - 100, - 95, - 118, - 105, - 97, - 95, - 99, - 97, - 115, - 116, - 40, - 38, - 112, - 97, - 105, - 114, - 41, - 32, - 61, - 61, - 32, - 55 - ], - "provenance": { - "ptrs": [] - }, - "align": 1, - "mutability": "Not" - } - } - } - ], - "functions": [ - [ - 0, - { - "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" - } - ], - [ - 13, - { - "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h9850ff6d26d0d49cE" - } - ], - [ - 14, - { - "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h1f8c021e0ac43527E" - } - ], - [ - 19, - { - "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h2d22a339bbdd2052E" - } - ], - [ - 20, - { - "IntrinsicSym": "black_box" - } - ], - [ - 21, - { - "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h34647d5ce086dc87E" - } - ], - [ - 23, - { - "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17ha5dc080083b58409E" - } - ], - [ - 32, - { - "NormalSym": "_ZN16struct_cast_fail13read_via_cast17hcc566435b7abf99eE" - } - ], - [ - 33, - { - "NormalSym": "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" - } - ], - [ - 41, - { - "NoOpSym": "" - } - ] - ], - "uneval_consts": [], - "items": [ - { - "symbol_name": "_ZN16struct_cast_fail13read_via_cast17hcc566435b7abf99eE", - "mono_item_kind": { - "MonoItemFn": { - "name": "read_via_cast", - "id": 6, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "AddressOf": [ - "Not", - { - "local": 1, - "projection": [ - "Deref" - ] - } - ] - } - ] - }, - "span": 51 - }, - { - "kind": { - "Assign": [ - { - "local": 2, - "projection": [] - }, - { - "Cast": [ - "PtrToPtr", - { - "Move": { - "local": 3, - "projection": [] - } - }, - 25 - ] - } - ] - }, - "span": 52 - }, - { - "kind": { - "Assign": [ - { - "local": 4, - "projection": [] - }, - { - "Cast": [ - "PtrToPtr", - { - "Copy": { - "local": 2, - "projection": [] - } - }, - 26 - ] - } - ] - }, - "span": 50 - }, - { - "kind": { - "Assign": [ - { - "local": 5, - "projection": [] - }, - { - "Cast": [ - "Transmute", - { - "Copy": { - "local": 4, - "projection": [] - } - }, - 27 - ] - } - ] - }, - "span": 50 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "NullaryOp": [ - "AlignOf", - 28 - ] - } - ] - }, - "span": 50 - }, - { - "kind": { - "Assign": [ - { - "local": 7, - "projection": [] - }, - { - "BinaryOp": [ - "Sub", - { - "Copy": { - "local": 6, - "projection": [] - } - }, - { - "Constant": { - "span": 50, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 27, - "id": 9 - } - } - } - ] - } - ] - }, - "span": 50 - }, - { - "kind": { - "Assign": [ - { - "local": 8, - "projection": [] - }, - { - "BinaryOp": [ - "BitAnd", - { - "Copy": { - "local": 5, - "projection": [] - } - }, - { - "Copy": { - "local": 7, - "projection": [] - } - } - ] - } - ] - }, - "span": 50 - }, - { - "kind": { - "Assign": [ - { - "local": 9, - "projection": [] - }, - { - "BinaryOp": [ - "Eq", - { - "Copy": { - "local": 8, - "projection": [] - } - }, - { - "Constant": { - "span": 50, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 27, - "id": 10 - } - } - } - ] - } - ] - }, - "span": 50 - } - ], - "terminator": { - "kind": { - "Assert": { - "cond": { - "Copy": { - "local": 9, - "projection": [] - } - }, - "expected": true, - "msg": { - "MisalignedPointerDereference": { - "required": { - "Copy": { - "local": 6, - "projection": [] - } - }, - "found": { - "Copy": { - "local": 5, - "projection": [] - } - } - } - }, - "target": 1, - "unwind": "Unreachable" - } - }, - "span": 50 - } - }, - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 2, - "projection": [ - "Deref" - ] - } - } - } - ] - }, - "span": 50 - } - ], - "terminator": { - "kind": "Return", - "span": 53 - } - } - ], - "locals": [ - { - "ty": 28, - "span": 54, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 55, - "mutability": "Not" - }, - { - "ty": 25, - "span": 52, - "mutability": "Mut" - }, - { - "ty": 30, - "span": 56, - "mutability": "Mut" - }, - { - "ty": 26, - "span": 50, - "mutability": "Mut" - }, - { - "ty": 27, - "span": 50, - "mutability": "Mut" - }, - { - "ty": 27, - "span": 50, - "mutability": "Mut" - }, - { - "ty": 27, - "span": 50, - "mutability": "Mut" - }, - { - "ty": 27, - "span": 50, - "mutability": "Mut" - }, - { - "ty": 31, - "span": 50, - "mutability": "Mut" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "pair", - "source_info": { - "span": 55, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 57 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN16struct_cast_fail4main17h10a9db70c2425cf7E", - "mono_item_kind": { - "MonoItemFn": { - "name": "main", - "id": 7, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 1, - "projection": [] - }, - { - "Aggregate": [ - { - "Adt": [ - 8, - 0, - [], - null, - null - ] - }, - [ - { - "Constant": { - "span": 60, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 7, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 28, - "id": 12 - } - } - }, - { - "Constant": { - "span": 61, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 1 - ], - "provenance": { - "ptrs": [] - }, - "align": 1, - "mutability": "Mut" - } - }, - "ty": 2, - "id": 13 - } - } - } - ] - ] - } - ] - }, - "span": 62 - }, - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 1, - "projection": [] - } - ] - } - ] - }, - "span": 63 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 58, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 32, - "id": 11 - } - } - }, - "args": [ - { - "Copy": { - "local": 3, - "projection": [] - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 59 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "SwitchInt": { - "discr": { - "Move": { - "local": 2, - "projection": [] - } - }, - "targets": { - "branches": [ - [ - 7, - 2 - ] - ], - "otherwise": 3 - } - } - }, - "span": 64 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 65 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 66, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 33, - "id": 14 - } - } - }, - "args": [ - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 43, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [ - [ - 0, - 0 - ] - ] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 34, - "id": 15 - } - } - } - ], - "destination": { - "local": 4, - "projection": [] - }, - "target": null, - "unwind": "Continue" - } - }, - "span": 66 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 67, - "mutability": "Mut" - }, - { - "ty": 35, - "span": 68, - "mutability": "Not" - }, - { - "ty": 28, - "span": 59, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 63, - "mutability": "Not" - }, - { - "ty": 36, - "span": 66, - "mutability": "Mut" - } - ], - "arg_count": 0, - "var_debug_info": [ - { - "name": "pair", - "source_info": { - "span": 68, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": null - } - ], - "spread_arg": null, - "span": 69 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std2rt10lang_start17h9664bd899e496584E", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::rt::lang_start::<()>", - "id": 0, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "StorageLive": 5 - }, - "span": 1 - }, - { - "kind": { - "StorageLive": 6 - }, - "span": 2 - }, - { - "kind": { - "StorageLive": 8 - }, - "span": 3 - }, - { - "kind": { - "Assign": [ - { - "local": 8, - "projection": [] - }, - { - "Aggregate": [ - { - "Closure": [ - 1, - [ - { - "Type": 1 - }, - { - "Type": 2 - }, - { - "Type": 3 - }, - { - "Type": 4 - } - ] - ] - }, - [ - { - "Copy": { - "local": 1, - "projection": [] - } - } - ] - ] - } - ] - }, - "span": 3 - }, - { - "kind": { - "Assign": [ - { - "local": 7, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 8, - "projection": [] - } - ] - } - ] - }, - "span": 2 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "Cast": [ - { - "PointerCoercion": "Unsize" - }, - { - "Copy": { - "local": 7, - "projection": [] - } - }, - 5 - ] - } - ] - }, - "span": 2 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 0, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 0, - "id": 0 - } - } - }, - "args": [ - { - "Move": { - "local": 6, - "projection": [] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - }, - { - "Move": { - "local": 3, - "projection": [] - } - }, - { - "Move": { - "local": 4, - "projection": [] - } - } - ], - "destination": { - "local": 5, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 1 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 6 - }, - "span": 5 - }, - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 5, - "projection": [ - { - "Downcast": 0 - }, - { - "Field": [ - 0, - 6 - ] - } - ] - } - } - } - ] - }, - "span": 6 - }, - { - "kind": { - "StorageDead": 8 - }, - "span": 7 - }, - { - "kind": { - "StorageDead": 5 - }, - "span": 7 - } - ], - "terminator": { - "kind": "Return", - "span": 4 - } - } - ], - "locals": [ - { - "ty": 6, - "span": 8, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 9, - "mutability": "Not" - }, - { - "ty": 6, - "span": 10, - "mutability": "Not" - }, - { - "ty": 8, - "span": 11, - "mutability": "Not" - }, - { - "ty": 9, - "span": 12, - "mutability": "Not" - }, - { - "ty": 10, - "span": 1, - "mutability": "Mut" - }, - { - "ty": 5, - "span": 2, - "mutability": "Mut" - }, - { - "ty": 11, - "span": 2, - "mutability": "Not" - }, - { - "ty": 12, - "span": 3, - "mutability": "Not" - } - ], - "arg_count": 4, - "var_debug_info": [ - { - "name": "main", - "source_info": { - "span": 9, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "argc", - "source_info": { - "span": 10, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 2, - "projection": [] - } - }, - "argument_index": 2 - }, - { - "name": "argv", - "source_info": { - "span": 11, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 3, - "projection": [] - } - }, - "argument_index": 3 - }, - { - "name": "sigpipe", - "source_info": { - "span": 12, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 4, - "projection": [] - } - }, - "argument_index": 4 - }, - { - "name": "v", - "source_info": { - "span": 6, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 0, - "projection": [] - } - }, - "argument_index": null - } - ], - "spread_arg": null, - "span": 13 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17ha5dc080083b58409E", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::rt::lang_start::<()>::{closure#0}", - "id": 1, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "StorageLive": 2 - }, - "span": 16 - }, - { - "kind": { - "StorageLive": 3 - }, - "span": 15 - }, - { - "kind": { - "StorageLive": 4 - }, - "span": 17 - }, - { - "kind": { - "Assign": [ - { - "local": 4, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 1, - "projection": [ - "Deref", - { - "Field": [ - 0, - 7 - ] - } - ] - } - } - } - ] - }, - "span": 17 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 14, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 13, - "id": 1 - } - } - }, - "args": [ - { - "Move": { - "local": 4, - "projection": [] - } - } - ], - "destination": { - "local": 3, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 15 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 4 - }, - "span": 19 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 18, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 14, - "id": 2 - } - } - }, - "args": [ - { - "Move": { - "local": 3, - "projection": [] - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 2, - "unwind": "Continue" - } - }, - "span": 16 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 3 - }, - "span": 21 - }, - { - "kind": { - "StorageLive": 5 - }, - "span": 22 - }, - { - "kind": { - "Assign": [ - { - "local": 5, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 2, - "projection": [ - { - "Field": [ - 0, - 15 - ] - } - ] - } - ] - } - ] - }, - "span": 22 - }, - { - "kind": { - "StorageLive": 6 - }, - "span": 23 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 2, - "projection": [ - { - "Field": [ - 0, - 15 - ] - }, - { - "Field": [ - 0, - 9 - ] - } - ] - } - } - } - ] - }, - "span": 23 - }, - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Cast": [ - "IntToInt", - { - "Move": { - "local": 6, - "projection": [] - } - }, - 16 - ] - } - ] - }, - "span": 24 - }, - { - "kind": { - "StorageDead": 6 - }, - "span": 25 - }, - { - "kind": { - "StorageDead": 5 - }, - "span": 26 - }, - { - "kind": { - "StorageDead": 2 - }, - "span": 27 - } - ], - "terminator": { - "kind": "Return", - "span": 20 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 28, - "mutability": "Mut" - }, - { - "ty": 11, - "span": 3, - "mutability": "Mut" - }, - { - "ty": 17, - "span": 16, - "mutability": "Mut" - }, - { - "ty": 1, - "span": 15, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 17, - "mutability": "Mut" - }, - { - "ty": 18, - "span": 22, - "mutability": "Mut" - }, - { - "ty": 9, - "span": 23, - "mutability": "Mut" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "main", - "source_info": { - "span": 9, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [ - "Deref", - { - "Field": [ - 0, - 7 - ] - } - ] - } - }, - "argument_index": null - }, - { - "name": "self", - "source_info": { - "span": 29, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 2, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "self", - "source_info": { - "span": 30, - "scope": 2 - }, - "composite": null, - "value": { - "Place": { - "local": 5, - "projection": [] - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 3 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h9850ff6d26d0d49cE", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::sys::backtrace::__rust_begin_short_backtrace::", - "id": 2, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 31, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 19, - "id": 3 - } - } - }, - "args": [ - { - "Move": { - "local": 1, - "projection": [] - } - }, - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 33 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 34, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 20, - "id": 5 - } - } - }, - "args": [ - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 2, - "unwind": "Unreachable" - } - }, - "span": 35 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 36 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 37, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 38, - "mutability": "Not" - }, - { - "ty": 1, - "span": 39, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "f", - "source_info": { - "span": 38, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "result", - "source_info": { - "span": 40, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 0, - "projection": [] - } - }, - "argument_index": null - }, - { - "name": "dummy", - "source_info": { - "span": 41, - "scope": 2 - }, - "composite": null, - "value": { - "Const": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 42 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17hd40535be7400a6f6E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 43, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 21, - "id": 6 - } - } - }, - "args": [ - { - "Move": { - "local": 1, - "projection": [ - "Deref" - ] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 22, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h2d22a339bbdd2052E", - "mono_item_kind": { - "MonoItemFn": { - "name": ">::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Move": { - "local": 1, - "projection": [] - } - }, - "args": [], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h34647d5ce086dc87E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - { - "Mut": { - "kind": "Default" - } - }, - { - "local": 1, - "projection": [] - } - ] - } - ] - }, - "span": 43 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 43, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 23, - "id": 7 - } - } - }, - "args": [ - { - "Move": { - "local": 3, - "projection": [] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": { - "Cleanup": 3 - } - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Drop": { - "place": { - "local": 1, - "projection": [] - }, - "target": 2, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Drop": { - "place": { - "local": 1, - "projection": [] - }, - "target": 4, - "unwind": "Terminate" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Resume", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 12, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - }, - { - "ty": 24, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h18fb8a505226337cE", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", - "id": 4, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 44 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 44, - "mutability": "Mut" - }, - { - "ty": 22, - "span": 44, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [], - "spread_arg": null, - "span": 44 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h1f8c021e0ac43527E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<() as std::process::Termination>::report", - "id": 5, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Constant": { - "span": 46, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 1, - "mutability": "Mut" - } - }, - "ty": 17, - "id": 8 - } - } - } - } - ] - }, - "span": 46 - } - ], - "terminator": { - "kind": "Return", - "span": 45 - } - } - ], - "locals": [ - { - "ty": 17, - "span": 47, - "mutability": "Mut" - }, - { - "ty": 1, - "span": 48, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "self", - "source_info": { - "span": 48, - "scope": 0 - }, - "composite": null, - "value": { - "Const": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 49 - } - } - }, - "details": null - } - ], - "types": [ - [ - 1, - { - "TupleType": { - "types": [], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Aggregate": { - "sized": true - } - }, - "abi_align": 1, - "size": { - "num_bits": 0 - } - } - } - } - ], - [ - 2, - { - "PrimitiveType": { - "Int": "I8" - } - } - ], - [ - 5, - { - "RefType": { - "pointee_type": 42, - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 64 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "ScalarPair": [ - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - }, - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - ] - }, - "abi_align": 8, - "size": { - "num_bits": 128 - } - } - } - } - ], - [ - 6, - { - "PrimitiveType": { - "Int": "Isize" - } - } - ], - [ - 8, - { - "PtrType": { - "pointee_type": 43, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 9, - { - "PrimitiveType": { - "Uint": "U8" - } - } - ], - [ - 10, - { - "EnumType": { - "name": "std::result::Result", - "adt_def": 27, - "discriminants": [ - 0, - 1 - ], - "fields": [ - [ - 6 - ], - [ - 36 - ] - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": true - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 11, - { - "RefType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 15, - { - "StructType": { - "name": "std::sys::pal::unix::process::process_common::ExitCode", - "adt_def": 19, - "fields": [ - 9 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I8", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 255 - } - } - } - }, - "abi_align": 1, - "size": { - "num_bits": 8 - } - } - } - } - ], - [ - 16, - { - "PrimitiveType": { - "Int": "I32" - } - } - ], - [ - 17, - { - "StructType": { - "name": "std::process::ExitCode", - "adt_def": 17, - "fields": [ - 15 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I8", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 255 - } - } - } - }, - "abi_align": 1, - "size": { - "num_bits": 8 - } - } - } - } - ], - [ - 18, - { - "RefType": { - "pointee_type": 15, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 22, - { - "PtrType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 24, - { - "RefType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 25, - { - "PtrType": { - "pointee_type": 28, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 26, - { - "PtrType": { - "pointee_type": 1, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 27, - { - "PrimitiveType": { - "Uint": "Usize" - } - } - ], - [ - 28, - { - "PrimitiveType": { - "Int": "I64" - } - } - ], - [ - 29, - { - "RefType": { - "pointee_type": 35, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 30, - { - "PtrType": { - "pointee_type": 35, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 31, - { - "PrimitiveType": "Bool" - } - ], - [ - 34, - { - "RefType": { - "pointee_type": 38, - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 64 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "ScalarPair": [ - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - }, - { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - ] - }, - "abi_align": 8, - "size": { - "num_bits": 128 - } - } - } - } - ], - [ - 35, - { - "StructType": { - "name": "Pair", - "adt_def": 8, - "fields": [ - 28, - 2 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 64 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "ScalarPair": [ - { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": true - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - }, - { - "Initialized": { - "value": { - "Int": { - "length": "I8", - "signed": true - } - }, - "valid_range": { - "start": 0, - "end": 255 - } - } - } - ] - }, - "abi_align": 8, - "size": { - "num_bits": 128 - } - } - } - } - ], - [ - 36, - "VoidType" - ], - [ - 37, - { - "RefType": { - "pointee_type": 39, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 38, - { - "PrimitiveType": "Str" - } - ], - [ - 39, - { - "StructType": { - "name": "std::panic::Location<'_>", - "adt_def": 12, - "fields": [ - 34, - 40, - 40 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 128 - }, - { - "num_bits": 160 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Aggregate": { - "sized": true - } - }, - "abi_align": 8, - "size": { - "num_bits": 192 - } - } - } - } - ], - [ - 40, - { - "PrimitiveType": { - "Uint": "U32" - } - } - ], - [ - 43, - { - "PtrType": { - "pointee_type": 9, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ] - ], - "spans": [ - [ - 0, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 17, - 194, - 36 - ] - ], - [ - 1, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 17, - 199, - 6 - ] - ], - [ - 2, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 9, - 195, - 93 - ] - ], - [ - 3, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 10, - 195, - 93 - ] - ], - [ - 4, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 201, - 2, - 201, - 2 - ] - ], - [ - 5, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 199, - 5, - 199, - 6 - ] - ], - [ - 6, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 12, - 194, - 13 - ] - ], - [ - 7, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 199, - 6, - 199, - 7 - ] - ], - [ - 9, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 189, - 5, - 189, - 9 - ] - ], - [ - 10, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 190, - 5, - 190, - 9 - ] - ], - [ - 11, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 191, - 5, - 191, - 9 - ] - ], - [ - 12, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 192, - 5, - 192, - 12 - ] - ], - [ - 13, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 188, - 1, - 201, - 2 - ] - ], - [ - 14, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 69 - ] - ], - [ - 15, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 75 - ] - ], - [ - 16, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 84 - ] - ], - [ - 17, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 70, - 195, - 74 - ] - ], - [ - 18, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 76, - 195, - 82 - ] - ], - [ - 19, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 74, - 195, - 75 - ] - ], - [ - 20, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 93, - 195, - 93 - ] - ], - [ - 21, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 83, - 195, - 84 - ] - ], - [ - 22, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2053, - 9, - 2053, - 15 - ] - ], - [ - 23, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 9, - 636, - 15 - ] - ], - [ - 24, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 9, - 636, - 22 - ] - ], - [ - 25, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 21, - 636, - 22 - ] - ], - [ - 26, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2053, - 23, - 2053, - 24 - ] - ], - [ - 27, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 92, - 195, - 93 - ] - ], - [ - 29, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2052, - 19, - 2052, - 23 - ] - ], - [ - 30, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 635, - 19, - 635, - 24 - ] - ], - [ - 31, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 18, - 154, - 19 - ] - ], - [ - 32, - [ - "no-location", - 0, - 0, - 0, - 0 - ] - ], - [ - 33, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 18, - 154, - 21 - ] - ], - [ - 34, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 389, - 5, - 389, - 33 - ] - ], - [ - 35, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 389, - 5, - 389, - 40 - ] - ], - [ - 36, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 160, - 2, - 160, - 2 - ] - ], - [ - 38, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 150, - 43, - 150, - 44 - ] - ], - [ - 40, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 9, - 154, - 15 - ] - ], - [ - 41, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 388, - 27, - 388, - 32 - ] - ], - [ - 42, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 150, - 1, - 160, - 2 - ] - ], - [ - 43, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", - 250, - 5, - 250, - 71 - ] - ], - [ - 44, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", - 521, - 1, - 521, - 56 - ] - ], - [ - 45, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2424, - 6, - 2424, - 6 - ] - ], - [ - 46, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2423, - 9, - 2423, - 26 - ] - ], - [ - 48, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2422, - 15, - 2422, - 19 - ] - ], - [ - 49, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2422, - 5, - 2424, - 6 - ] - ], - [ - 50, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 7, - 14, - 7, - 50 - ] - ], - [ - 51, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 7, - 16, - 7, - 20 - ] - ], - [ - 52, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 7, - 15, - 7, - 50 - ] - ], - [ - 53, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 8, - 2, - 8, - 2 - ] - ], - [ - 55, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 6, - 18, - 6, - 22 - ] - ], - [ - 57, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 6, - 1, - 8, - 2 - ] - ], - [ - 58, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 12, - 13, - 12, - 26 - ] - ], - [ - 59, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 12, - 13, - 12, - 33 - ] - ], - [ - 60, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 11, - 29, - 11, - 30 - ] - ], - [ - 61, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 11, - 38, - 11, - 39 - ] - ], - [ - 62, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 11, - 16, - 11, - 41 - ] - ], - [ - 63, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 12, - 27, - 12, - 32 - ] - ], - [ - 64, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 12, - 13, - 12, - 38 - ] - ], - [ - 65, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 13, - 2, - 13, - 2 - ] - ], - [ - 66, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 12, - 5, - 12, - 39 - ] - ], - [ - 68, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 11, - 9, - 11, - 13 - ] - ], - [ - 69, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs", - 10, - 1, - 13, - 2 - ] - ] - ], - "debug": null, - "machine": { - "endian": "Little", - "pointer_width": { - "num_bits": 64 - } - } -} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state deleted file mode 100644 index cd9c167f9..000000000 --- a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.state +++ /dev/null @@ -1,101 +0,0 @@ - - - #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) ) ~> #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K - - - noReturn - - - ty ( 32 ) - - - - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) - - - ty ( -1 ) - - - place (... local: local ( 2 ) , projection: .ProjectionElems ) - - - someBasicBlockIdx ( basicBlockIdx ( 1 ) ) - - - unwindActionContinue - - - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) - - - - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) - ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) - ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) - - -#Or - - - #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , projectionElemDeref .ProjectionElems , .Contexts ) ~> #readProjection ( false ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 0 ) , projection: .ProjectionElems ) ~> .K ) ~> #execStmts ( .Statements ) ~> #execTerminator ( terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ~> .K - - - noReturn - - - ty ( 32 ) - - - - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 1 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 51 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 28 ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 9 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 8 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 27 ) , id: mirConstId ( 10 ) ) ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionUnreachable ) , span: span ( 50 ) ) ) ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 2 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 53 ) ) ) ) - - - ty ( -1 ) - - - place (... local: local ( 2 ) , projection: .ProjectionElems ) - - - someBasicBlockIdx ( basicBlockIdx ( 1 ) ) - - - unwindActionContinue - - - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( typedValue ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Moved , ty ( 30 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , ty ( 26 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 8 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( Integer ( 7 , 64 , false ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , ty ( 27 ) , mutabilityMut ) ) - ListItem ( typedValue ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , thunk ( #cast ( thunk ( #cast ( thunk ( #cast ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , castKindPtrToPtr , ty ( 30 ) , ty ( 25 ) ) ) , castKindPtrToPtr , ty ( 25 ) , ty ( 26 ) ) ) , castKindTransmute , ty ( 26 ) , ty ( 27 ) ) ) , Integer ( 7 , 64 , false ) , false ) ) , Integer ( 0 , 64 , false ) , false ) ) , ty ( 31 ) , mutabilityMut ) ) - - - - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) - ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 7 , 64 , true ) ) - ListItem ( Integer ( 1 , 8 , true ) ) ) , ty ( 35 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 28 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 29 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 36 ) , mutabilityMut ) ) ) ) - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) - - \ No newline at end of file diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json deleted file mode 100644 index 7bd6e5a12..000000000 --- a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.smir.json +++ /dev/null @@ -1,3763 +0,0 @@ -{ - "name": "unsafe_cell_cast", - "crate_id": 17972866091748300451, - "allocs": [ - { - "alloc_id": 1, - "ty": 39, - "global_alloc": { - "Memory": { - "bytes": [ - 97, - 115, - 115, - 101, - 114, - 116, - 105, - 111, - 110, - 32, - 102, - 97, - 105, - 108, - 101, - 100, - 58, - 32, - 114, - 101, - 97, - 100, - 40, - 38, - 99, - 101, - 108, - 108, - 41, - 32, - 61, - 61, - 32, - 52, - 49 - ], - "provenance": { - "ptrs": [] - }, - "align": 1, - "mutability": "Not" - } - } - } - ], - "functions": [ - [ - 0, - { - "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" - } - ], - [ - 13, - { - "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h61408a798a23843cE" - } - ], - [ - 14, - { - "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h76efa01750d221f7E" - } - ], - [ - 19, - { - "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17hb6e80083da3c9b59E" - } - ], - [ - 20, - { - "IntrinsicSym": "black_box" - } - ], - [ - 21, - { - "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h47a589645b5b7a97E" - } - ], - [ - 23, - { - "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h74d64ac5485153d0E" - } - ], - [ - 33, - { - "NormalSym": "_ZN4core4cell19UnsafeCell$LT$T$GT$3new17hc140826c67c3f8f1E" - } - ], - [ - 34, - { - "NormalSym": "_ZN16unsafe_cell_cast4read17h7e34b1aad334a87dE" - } - ], - [ - 35, - { - "NormalSym": "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" - } - ], - [ - 42, - { - "NoOpSym": "" - } - ] - ], - "uneval_consts": [], - "items": [ - { - "symbol_name": "_ZN16unsafe_cell_cast4main17h6e92912a3353492eE", - "mono_item_kind": { - "MonoItemFn": { - "name": "main", - "id": 9, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 64, - "user_ty": 0, - "const_": { - "kind": "ZeroSized", - "ty": 33, - "id": 11 - } - } - }, - "args": [ - { - "Constant": { - "span": 65, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 41, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 25, - "id": 12 - } - } - } - ], - "destination": { - "local": 1, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 66 - } - }, - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 1, - "projection": [] - } - ] - } - ] - }, - "span": 69 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 67, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 34, - "id": 13 - } - } - }, - "args": [ - { - "Copy": { - "local": 3, - "projection": [] - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 2, - "unwind": "Continue" - } - }, - "span": 68 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "SwitchInt": { - "discr": { - "Move": { - "local": 2, - "projection": [] - } - }, - "targets": { - "branches": [ - [ - 41, - 3 - ] - ], - "otherwise": 4 - } - } - }, - "span": 70 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 71 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 72, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 35, - "id": 14 - } - } - }, - "args": [ - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 35, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [ - [ - 0, - 0 - ] - ] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 36, - "id": 15 - } - } - } - ], - "destination": { - "local": 4, - "projection": [] - }, - "target": null, - "unwind": "Continue" - } - }, - "span": 72 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 73, - "mutability": "Mut" - }, - { - "ty": 26, - "span": 74, - "mutability": "Not" - }, - { - "ty": 25, - "span": 68, - "mutability": "Mut" - }, - { - "ty": 30, - "span": 69, - "mutability": "Not" - }, - { - "ty": 37, - "span": 72, - "mutability": "Mut" - } - ], - "arg_count": 0, - "var_debug_info": [ - { - "name": "cell", - "source_info": { - "span": 74, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": null - } - ], - "spread_arg": null, - "span": 75 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN16unsafe_cell_cast4read17h7e34b1aad334a87dE", - "mono_item_kind": { - "MonoItemFn": { - "name": "read", - "id": 8, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 2, - "projection": [] - }, - { - "AddressOf": [ - "Not", - { - "local": 1, - "projection": [ - "Deref" - ] - } - ] - } - ] - }, - "span": 56 - }, - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "Cast": [ - "PtrToPtr", - { - "Copy": { - "local": 2, - "projection": [] - } - }, - 27 - ] - } - ] - }, - "span": 57 - }, - { - "kind": { - "Assign": [ - { - "local": 4, - "projection": [] - }, - { - "Cast": [ - "PtrToPtr", - { - "Copy": { - "local": 3, - "projection": [] - } - }, - 28 - ] - } - ] - }, - "span": 55 - }, - { - "kind": { - "Assign": [ - { - "local": 5, - "projection": [] - }, - { - "Cast": [ - "Transmute", - { - "Copy": { - "local": 4, - "projection": [] - } - }, - 29 - ] - } - ] - }, - "span": 55 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "NullaryOp": [ - "AlignOf", - 25 - ] - } - ] - }, - "span": 55 - }, - { - "kind": { - "Assign": [ - { - "local": 7, - "projection": [] - }, - { - "BinaryOp": [ - "Sub", - { - "Copy": { - "local": 6, - "projection": [] - } - }, - { - "Constant": { - "span": 55, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 29, - "id": 9 - } - } - } - ] - } - ] - }, - "span": 55 - }, - { - "kind": { - "Assign": [ - { - "local": 8, - "projection": [] - }, - { - "BinaryOp": [ - "BitAnd", - { - "Copy": { - "local": 5, - "projection": [] - } - }, - { - "Copy": { - "local": 7, - "projection": [] - } - } - ] - } - ] - }, - "span": 55 - }, - { - "kind": { - "Assign": [ - { - "local": 9, - "projection": [] - }, - { - "BinaryOp": [ - "Eq", - { - "Copy": { - "local": 8, - "projection": [] - } - }, - { - "Constant": { - "span": 55, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 8, - "mutability": "Mut" - } - }, - "ty": 29, - "id": 10 - } - } - } - ] - } - ] - }, - "span": 55 - } - ], - "terminator": { - "kind": { - "Assert": { - "cond": { - "Copy": { - "local": 9, - "projection": [] - } - }, - "expected": true, - "msg": { - "MisalignedPointerDereference": { - "required": { - "Copy": { - "local": 6, - "projection": [] - } - }, - "found": { - "Copy": { - "local": 5, - "projection": [] - } - } - } - }, - "target": 1, - "unwind": "Unreachable" - } - }, - "span": 55 - } - }, - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 3, - "projection": [ - "Deref" - ] - } - } - } - ] - }, - "span": 55 - } - ], - "terminator": { - "kind": "Return", - "span": 58 - } - } - ], - "locals": [ - { - "ty": 25, - "span": 59, - "mutability": "Mut" - }, - { - "ty": 30, - "span": 60, - "mutability": "Not" - }, - { - "ty": 31, - "span": 61, - "mutability": "Not" - }, - { - "ty": 27, - "span": 62, - "mutability": "Not" - }, - { - "ty": 28, - "span": 55, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 55, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 55, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 55, - "mutability": "Mut" - }, - { - "ty": 29, - "span": 55, - "mutability": "Mut" - }, - { - "ty": 32, - "span": 55, - "mutability": "Mut" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "cell", - "source_info": { - "span": 60, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "raw", - "source_info": { - "span": 61, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 2, - "projection": [] - } - }, - "argument_index": null - }, - { - "name": "inner", - "source_info": { - "span": 62, - "scope": 2 - }, - "composite": null, - "value": { - "Place": { - "local": 3, - "projection": [] - } - }, - "argument_index": null - } - ], - "spread_arg": null, - "span": 63 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std2rt10lang_start17hb3f3726bf09716b2E", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::rt::lang_start::<()>", - "id": 0, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "StorageLive": 5 - }, - "span": 1 - }, - { - "kind": { - "StorageLive": 6 - }, - "span": 2 - }, - { - "kind": { - "StorageLive": 8 - }, - "span": 3 - }, - { - "kind": { - "Assign": [ - { - "local": 8, - "projection": [] - }, - { - "Aggregate": [ - { - "Closure": [ - 1, - [ - { - "Type": 1 - }, - { - "Type": 2 - }, - { - "Type": 3 - }, - { - "Type": 4 - } - ] - ] - }, - [ - { - "Copy": { - "local": 1, - "projection": [] - } - } - ] - ] - } - ] - }, - "span": 3 - }, - { - "kind": { - "Assign": [ - { - "local": 7, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 8, - "projection": [] - } - ] - } - ] - }, - "span": 2 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "Cast": [ - { - "PointerCoercion": "Unsize" - }, - { - "Copy": { - "local": 7, - "projection": [] - } - }, - 5 - ] - } - ] - }, - "span": 2 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 0, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 0, - "id": 0 - } - } - }, - "args": [ - { - "Move": { - "local": 6, - "projection": [] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - }, - { - "Move": { - "local": 3, - "projection": [] - } - }, - { - "Move": { - "local": 4, - "projection": [] - } - } - ], - "destination": { - "local": 5, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 1 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 6 - }, - "span": 5 - }, - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 5, - "projection": [ - { - "Downcast": 0 - }, - { - "Field": [ - 0, - 6 - ] - } - ] - } - } - } - ] - }, - "span": 6 - }, - { - "kind": { - "StorageDead": 8 - }, - "span": 7 - }, - { - "kind": { - "StorageDead": 5 - }, - "span": 7 - } - ], - "terminator": { - "kind": "Return", - "span": 4 - } - } - ], - "locals": [ - { - "ty": 6, - "span": 8, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 9, - "mutability": "Not" - }, - { - "ty": 6, - "span": 10, - "mutability": "Not" - }, - { - "ty": 8, - "span": 11, - "mutability": "Not" - }, - { - "ty": 9, - "span": 12, - "mutability": "Not" - }, - { - "ty": 10, - "span": 1, - "mutability": "Mut" - }, - { - "ty": 5, - "span": 2, - "mutability": "Mut" - }, - { - "ty": 11, - "span": 2, - "mutability": "Not" - }, - { - "ty": 12, - "span": 3, - "mutability": "Not" - } - ], - "arg_count": 4, - "var_debug_info": [ - { - "name": "main", - "source_info": { - "span": 9, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "argc", - "source_info": { - "span": 10, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 2, - "projection": [] - } - }, - "argument_index": 2 - }, - { - "name": "argv", - "source_info": { - "span": 11, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 3, - "projection": [] - } - }, - "argument_index": 3 - }, - { - "name": "sigpipe", - "source_info": { - "span": 12, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 4, - "projection": [] - } - }, - "argument_index": 4 - }, - { - "name": "v", - "source_info": { - "span": 6, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 0, - "projection": [] - } - }, - "argument_index": null - } - ], - "spread_arg": null, - "span": 13 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h74d64ac5485153d0E", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::rt::lang_start::<()>::{closure#0}", - "id": 1, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "StorageLive": 2 - }, - "span": 16 - }, - { - "kind": { - "StorageLive": 3 - }, - "span": 15 - }, - { - "kind": { - "StorageLive": 4 - }, - "span": 17 - }, - { - "kind": { - "Assign": [ - { - "local": 4, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 1, - "projection": [ - "Deref", - { - "Field": [ - 0, - 7 - ] - } - ] - } - } - } - ] - }, - "span": 17 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 14, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 13, - "id": 1 - } - } - }, - "args": [ - { - "Move": { - "local": 4, - "projection": [] - } - } - ], - "destination": { - "local": 3, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 15 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 4 - }, - "span": 19 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 18, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 14, - "id": 2 - } - } - }, - "args": [ - { - "Move": { - "local": 3, - "projection": [] - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 2, - "unwind": "Continue" - } - }, - "span": 16 - } - }, - { - "statements": [ - { - "kind": { - "StorageDead": 3 - }, - "span": 21 - }, - { - "kind": { - "StorageLive": 5 - }, - "span": 22 - }, - { - "kind": { - "Assign": [ - { - "local": 5, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - "Shared", - { - "local": 2, - "projection": [ - { - "Field": [ - 0, - 15 - ] - } - ] - } - ] - } - ] - }, - "span": 22 - }, - { - "kind": { - "StorageLive": 6 - }, - "span": 23 - }, - { - "kind": { - "Assign": [ - { - "local": 6, - "projection": [] - }, - { - "Use": { - "Copy": { - "local": 2, - "projection": [ - { - "Field": [ - 0, - 15 - ] - }, - { - "Field": [ - 0, - 9 - ] - } - ] - } - } - } - ] - }, - "span": 23 - }, - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Cast": [ - "IntToInt", - { - "Move": { - "local": 6, - "projection": [] - } - }, - 16 - ] - } - ] - }, - "span": 24 - }, - { - "kind": { - "StorageDead": 6 - }, - "span": 25 - }, - { - "kind": { - "StorageDead": 5 - }, - "span": 26 - }, - { - "kind": { - "StorageDead": 2 - }, - "span": 27 - } - ], - "terminator": { - "kind": "Return", - "span": 20 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 28, - "mutability": "Mut" - }, - { - "ty": 11, - "span": 3, - "mutability": "Mut" - }, - { - "ty": 17, - "span": 16, - "mutability": "Mut" - }, - { - "ty": 1, - "span": 15, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 17, - "mutability": "Mut" - }, - { - "ty": 18, - "span": 22, - "mutability": "Mut" - }, - { - "ty": 9, - "span": 23, - "mutability": "Mut" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "main", - "source_info": { - "span": 9, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [ - "Deref", - { - "Field": [ - 0, - 7 - ] - } - ] - } - }, - "argument_index": null - }, - { - "name": "self", - "source_info": { - "span": 29, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 2, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "self", - "source_info": { - "span": 30, - "scope": 2 - }, - "composite": null, - "value": { - "Place": { - "local": 5, - "projection": [] - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 3 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h61408a798a23843cE", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::sys::backtrace::__rust_begin_short_backtrace::", - "id": 2, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 31, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 19, - "id": 3 - } - } - }, - "args": [ - { - "Move": { - "local": 1, - "projection": [] - } - }, - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 33 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 34, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 20, - "id": 5 - } - } - }, - "args": [ - { - "Constant": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - } - ], - "destination": { - "local": 2, - "projection": [] - }, - "target": 2, - "unwind": "Unreachable" - } - }, - "span": 35 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 36 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 37, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 38, - "mutability": "Not" - }, - { - "ty": 1, - "span": 39, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "f", - "source_info": { - "span": 38, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - }, - { - "name": "result", - "source_info": { - "span": 40, - "scope": 1 - }, - "composite": null, - "value": { - "Place": { - "local": 0, - "projection": [] - } - }, - "argument_index": null - }, - { - "name": "dummy", - "source_info": { - "span": 41, - "scope": 2 - }, - "composite": null, - "value": { - "Const": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 42 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h95156b73cd583802E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 43, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 21, - "id": 6 - } - } - }, - "args": [ - { - "Move": { - "local": 1, - "projection": [ - "Deref" - ] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 22, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h47a589645b5b7a97E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 3, - "projection": [] - }, - { - "Ref": [ - { - "kind": "ReErased" - }, - { - "Mut": { - "kind": "Default" - } - }, - { - "local": 1, - "projection": [] - } - ] - } - ] - }, - "span": 43 - } - ], - "terminator": { - "kind": { - "Call": { - "func": { - "Constant": { - "span": 43, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 23, - "id": 7 - } - } - }, - "args": [ - { - "Move": { - "local": 3, - "projection": [] - } - }, - { - "Move": { - "local": 2, - "projection": [] - } - } - ], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": { - "Cleanup": 3 - } - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Drop": { - "place": { - "local": 1, - "projection": [] - }, - "target": 2, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": { - "Drop": { - "place": { - "local": 1, - "projection": [] - }, - "target": 4, - "unwind": "Terminate" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Resume", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 16, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 12, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - }, - { - "ty": 24, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17hb6e80083da3c9b59E", - "mono_item_kind": { - "MonoItemFn": { - "name": ">::call_once", - "id": 3, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": { - "Call": { - "func": { - "Move": { - "local": 1, - "projection": [] - } - }, - "args": [], - "destination": { - "local": 0, - "projection": [] - }, - "target": 1, - "unwind": "Continue" - } - }, - "span": 43 - } - }, - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 43 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 43, - "mutability": "Mut" - }, - { - "ty": 7, - "span": 43, - "mutability": "Not" - }, - { - "ty": 1, - "span": 43, - "mutability": "Not" - } - ], - "arg_count": 2, - "var_debug_info": [], - "spread_arg": 2, - "span": 43 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h5fbb76094b60164eE", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", - "id": 4, - "body": { - "blocks": [ - { - "statements": [], - "terminator": { - "kind": "Return", - "span": 44 - } - } - ], - "locals": [ - { - "ty": 1, - "span": 44, - "mutability": "Mut" - }, - { - "ty": 22, - "span": 44, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [], - "spread_arg": null, - "span": 44 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN4core4cell19UnsafeCell$LT$T$GT$3new17hc140826c67c3f8f1E", - "mono_item_kind": { - "MonoItemFn": { - "name": "std::cell::UnsafeCell::::new", - "id": 5, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Aggregate": [ - { - "Adt": [ - 6, - 0, - [ - { - "Type": 25 - } - ], - null, - null - ] - }, - [ - { - "Copy": { - "local": 1, - "projection": [] - } - } - ] - ] - } - ] - }, - "span": 46 - } - ], - "terminator": { - "kind": "Return", - "span": 45 - } - } - ], - "locals": [ - { - "ty": 26, - "span": 47, - "mutability": "Mut" - }, - { - "ty": 25, - "span": 48, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "value", - "source_info": { - "span": 48, - "scope": 0 - }, - "composite": null, - "value": { - "Place": { - "local": 1, - "projection": [] - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 49 - } - } - }, - "details": null - }, - { - "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h76efa01750d221f7E", - "mono_item_kind": { - "MonoItemFn": { - "name": "<() as std::process::Termination>::report", - "id": 7, - "body": { - "blocks": [ - { - "statements": [ - { - "kind": { - "Assign": [ - { - "local": 0, - "projection": [] - }, - { - "Use": { - "Constant": { - "span": 51, - "user_ty": null, - "const_": { - "kind": { - "Allocated": { - "bytes": [ - 0 - ], - "provenance": { - "ptrs": [] - }, - "align": 1, - "mutability": "Mut" - } - }, - "ty": 17, - "id": 8 - } - } - } - } - ] - }, - "span": 51 - } - ], - "terminator": { - "kind": "Return", - "span": 50 - } - } - ], - "locals": [ - { - "ty": 17, - "span": 52, - "mutability": "Mut" - }, - { - "ty": 1, - "span": 53, - "mutability": "Not" - } - ], - "arg_count": 1, - "var_debug_info": [ - { - "name": "self", - "source_info": { - "span": 53, - "scope": 0 - }, - "composite": null, - "value": { - "Const": { - "span": 32, - "user_ty": null, - "const_": { - "kind": "ZeroSized", - "ty": 1, - "id": 4 - } - } - }, - "argument_index": 1 - } - ], - "spread_arg": null, - "span": 54 - } - } - }, - "details": null - } - ], - "types": [ - [ - 1, - { - "TupleType": { - "types": [], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Aggregate": { - "sized": true - } - }, - "abi_align": 1, - "size": { - "num_bits": 0 - } - } - } - } - ], - [ - 5, - { - "RefType": { - "pointee_type": 43, - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 64 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "ScalarPair": [ - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - }, - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - ] - }, - "abi_align": 8, - "size": { - "num_bits": 128 - } - } - } - } - ], - [ - 6, - { - "PrimitiveType": { - "Int": "Isize" - } - } - ], - [ - 8, - { - "PtrType": { - "pointee_type": 44, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 9, - { - "PrimitiveType": { - "Uint": "U8" - } - } - ], - [ - 10, - { - "EnumType": { - "name": "std::result::Result", - "adt_def": 22, - "discriminants": [ - 0, - 1 - ], - "fields": [ - [ - 6 - ], - [ - 37 - ] - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": true - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 11, - { - "RefType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 15, - { - "StructType": { - "name": "std::sys::pal::unix::process::process_common::ExitCode", - "adt_def": 28, - "fields": [ - 9 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I8", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 255 - } - } - } - }, - "abi_align": 1, - "size": { - "num_bits": 8 - } - } - } - } - ], - [ - 16, - { - "PrimitiveType": { - "Int": "I32" - } - } - ], - [ - 17, - { - "StructType": { - "name": "std::process::ExitCode", - "adt_def": 26, - "fields": [ - 15 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I8", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 255 - } - } - } - }, - "abi_align": 1, - "size": { - "num_bits": 8 - } - } - } - } - ], - [ - 18, - { - "RefType": { - "pointee_type": 15, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 22, - { - "PtrType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 24, - { - "RefType": { - "pointee_type": 12, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 25, - { - "PrimitiveType": { - "Int": "I64" - } - } - ], - [ - 26, - { - "StructType": { - "name": "std::cell::UnsafeCell", - "adt_def": 6, - "fields": [ - 25 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": true - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 27, - { - "PtrType": { - "pointee_type": 25, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 28, - { - "PtrType": { - "pointee_type": 1, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 29, - { - "PrimitiveType": { - "Uint": "Usize" - } - } - ], - [ - 30, - { - "RefType": { - "pointee_type": 26, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 31, - { - "PtrType": { - "pointee_type": 26, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 32, - { - "PrimitiveType": "Bool" - } - ], - [ - 36, - { - "RefType": { - "pointee_type": 39, - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 64 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "ScalarPair": [ - { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - }, - { - "Initialized": { - "value": { - "Int": { - "length": "I64", - "signed": false - } - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - ] - }, - "abi_align": 8, - "size": { - "num_bits": 128 - } - } - } - } - ], - [ - 37, - "VoidType" - ], - [ - 38, - { - "RefType": { - "pointee_type": 40, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 1, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ], - [ - 39, - { - "PrimitiveType": "Str" - } - ], - [ - 40, - { - "StructType": { - "name": "std::panic::Location<'_>", - "adt_def": 12, - "fields": [ - 36, - 41, - 41 - ], - "layout": { - "fields": { - "Arbitrary": { - "offsets": [ - { - "num_bits": 0 - }, - { - "num_bits": 128 - }, - { - "num_bits": 160 - } - ] - } - }, - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Aggregate": { - "sized": true - } - }, - "abi_align": 8, - "size": { - "num_bits": 192 - } - } - } - } - ], - [ - 41, - { - "PrimitiveType": { - "Uint": "U32" - } - } - ], - [ - 44, - { - "PtrType": { - "pointee_type": 9, - "layout": { - "fields": "Primitive", - "variants": { - "Single": { - "index": 0 - } - }, - "abi": { - "Scalar": { - "Initialized": { - "value": { - "Pointer": 0 - }, - "valid_range": { - "start": 0, - "end": 18446744073709551615 - } - } - } - }, - "abi_align": 8, - "size": { - "num_bits": 64 - } - } - } - } - ] - ], - "spans": [ - [ - 0, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 17, - 194, - 36 - ] - ], - [ - 1, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 17, - 199, - 6 - ] - ], - [ - 2, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 9, - 195, - 93 - ] - ], - [ - 3, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 10, - 195, - 93 - ] - ], - [ - 4, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 201, - 2, - 201, - 2 - ] - ], - [ - 5, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 199, - 5, - 199, - 6 - ] - ], - [ - 6, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 194, - 12, - 194, - 13 - ] - ], - [ - 7, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 199, - 6, - 199, - 7 - ] - ], - [ - 9, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 189, - 5, - 189, - 9 - ] - ], - [ - 10, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 190, - 5, - 190, - 9 - ] - ], - [ - 11, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 191, - 5, - 191, - 9 - ] - ], - [ - 12, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 192, - 5, - 192, - 12 - ] - ], - [ - 13, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 188, - 1, - 201, - 2 - ] - ], - [ - 14, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 69 - ] - ], - [ - 15, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 75 - ] - ], - [ - 16, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 18, - 195, - 84 - ] - ], - [ - 17, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 70, - 195, - 74 - ] - ], - [ - 18, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 76, - 195, - 82 - ] - ], - [ - 19, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 74, - 195, - 75 - ] - ], - [ - 20, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 93, - 195, - 93 - ] - ], - [ - 21, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 83, - 195, - 84 - ] - ], - [ - 22, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2053, - 9, - 2053, - 15 - ] - ], - [ - 23, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 9, - 636, - 15 - ] - ], - [ - 24, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 9, - 636, - 22 - ] - ], - [ - 25, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 636, - 21, - 636, - 22 - ] - ], - [ - 26, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2053, - 23, - 2053, - 24 - ] - ], - [ - 27, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", - 195, - 92, - 195, - 93 - ] - ], - [ - 29, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2052, - 19, - 2052, - 23 - ] - ], - [ - 30, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/pal/unix/process/process_common.rs", - 635, - 19, - 635, - 24 - ] - ], - [ - 31, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 18, - 154, - 19 - ] - ], - [ - 32, - [ - "no-location", - 0, - 0, - 0, - 0 - ] - ], - [ - 33, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 18, - 154, - 21 - ] - ], - [ - 34, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 389, - 5, - 389, - 33 - ] - ], - [ - 35, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 389, - 5, - 389, - 40 - ] - ], - [ - 36, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 160, - 2, - 160, - 2 - ] - ], - [ - 38, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 150, - 43, - 150, - 44 - ] - ], - [ - 40, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 154, - 9, - 154, - 15 - ] - ], - [ - 41, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", - 388, - 27, - 388, - 32 - ] - ], - [ - 42, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/sys/backtrace.rs", - 150, - 1, - 160, - 2 - ] - ], - [ - 43, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", - 250, - 5, - 250, - 71 - ] - ], - [ - 44, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", - 521, - 1, - 521, - 56 - ] - ], - [ - 45, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", - 2099, - 6, - 2099, - 6 - ] - ], - [ - 46, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", - 2098, - 9, - 2098, - 29 - ] - ], - [ - 48, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", - 2097, - 22, - 2097, - 27 - ] - ], - [ - 49, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/cell.rs", - 2097, - 5, - 2099, - 6 - ] - ], - [ - 50, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2424, - 6, - 2424, - 6 - ] - ], - [ - 51, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2423, - 9, - 2423, - 26 - ] - ], - [ - 53, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2422, - 15, - 2422, - 19 - ] - ], - [ - 54, - [ - "/Users/steven/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", - 2422, - 5, - 2424, - 6 - ] - ], - [ - 55, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 7, - 9, - 7, - 15 - ] - ], - [ - 56, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 5, - 43, - 5, - 47 - ] - ], - [ - 57, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 6, - 33, - 6, - 50 - ] - ], - [ - 58, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 9, - 2, - 9, - 2 - ] - ], - [ - 60, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 3, - 9, - 3, - 13 - ] - ], - [ - 61, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 5, - 13, - 5, - 16 - ] - ], - [ - 62, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 6, - 13, - 6, - 18 - ] - ], - [ - 63, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 3, - 1, - 9, - 2 - ] - ], - [ - 64, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 12, - 16, - 12, - 31 - ] - ], - [ - 65, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 12, - 32, - 12, - 34 - ] - ], - [ - 66, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 12, - 16, - 12, - 35 - ] - ], - [ - 67, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 13, - 13, - 13, - 17 - ] - ], - [ - 68, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 13, - 13, - 13, - 24 - ] - ], - [ - 69, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 13, - 18, - 13, - 23 - ] - ], - [ - 70, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 13, - 13, - 13, - 30 - ] - ], - [ - 71, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 14, - 2, - 14, - 2 - ] - ], - [ - 72, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 13, - 5, - 13, - 31 - ] - ], - [ - 74, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 12, - 9, - 12, - 13 - ] - ], - [ - 75, - [ - "/Users/steven/Desktop/projs/kmir/mir0/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs", - 11, - 1, - 14, - 2 - ] - ] - ], - "debug": null, - "machine": { - "endian": "Little", - "pointer_width": { - "num_bits": 64 - } - } -} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state b/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state deleted file mode 100644 index 0f712290e..000000000 --- a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.state +++ /dev/null @@ -1,42 +0,0 @@ - - - #EndProgram ~> .K - - - noReturn - - - ty ( -1 ) - - - - ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 64 ) , userTy: someUserTypeAnnotationIndex ( userTypeAnnotationIndex ( 0 ) ) , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 33 ) , id: mirConstId ( 11 ) ) ) ) , args: operandConstant ( constOperand (... span: span ( 65 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b")\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 25 ) , id: mirConstId ( 12 ) ) ) ) .Operands , destination: place (... local: local ( 1 ) , projection: .ProjectionElems ) , target: someBasicBlockIdx ( basicBlockIdx ( 1 ) ) , unwind: unwindActionContinue ) , span: span ( 66 ) ) ) ) - ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 1 ) , projection: .ProjectionElems ) ) ) , span: span ( 69 ) ) .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 67 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 34 ) , id: mirConstId ( 13 ) ) ) ) , args: operandCopy ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) .Operands , destination: place (... local: local ( 2 ) , projection: .ProjectionElems ) , target: someBasicBlockIdx ( basicBlockIdx ( 2 ) ) , unwind: unwindActionContinue ) , span: span ( 68 ) ) ) ) - ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindSwitchInt (... discr: operandMove ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , targets: switchTargets (... branches: branch ( 41 , basicBlockIdx ( 3 ) ) .Branches , otherwise: basicBlockIdx ( 4 ) ) ) , span: span ( 70 ) ) ) ) - ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 71 ) ) ) ) - ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 72 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 35 ) , id: mirConstId ( 14 ) ) ) ) , args: operandConstant ( constOperand (... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: provenanceMapEntry (... offset: 0 , allocId: allocId ( 0 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 36 ) , id: mirConstId ( 15 ) ) ) ) .Operands , destination: place (... local: local ( 4 ) , projection: .ProjectionElems ) , target: noBasicBlockIdx , unwind: unwindActionContinue ) , span: span ( 72 ) ) ) ) - - - ty ( -1 ) - - - place (... local: local ( 0 ) , projection: .ProjectionElems ) - - - noBasicBlockIdx - - - unwindActionContinue - - - ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) - ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Integer ( 41 , 64 , true ) ) ) , ty ( 26 ) , mutabilityNot ) ) - ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) - ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 30 ) , mutabilityNot ) ) - ListItem ( newLocal ( ty ( 37 ) , mutabilityMut ) ) - - - - ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( -1 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionUnreachable , .List ) ) - - \ No newline at end of file diff --git a/kmir/src/tests/integration/data/prove-rs/refcell.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell-fail.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/refcell.rs rename to kmir/src/tests/integration/data/prove-rs/interior-mut-refcell-fail.rs diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs b/kmir/src/tests/integration/data/prove-rs/pointer-cast-struct-field-fail.rs similarity index 100% rename from kmir/src/tests/integration/data/exec-smir/pointers/struct_cast_fail.rs rename to kmir/src/tests/integration/data/prove-rs/pointer-cast-struct-field-fail.rs diff --git a/kmir/src/tests/integration/data/prove-rs/pointer-cast-transparent-wrapper.rs b/kmir/src/tests/integration/data/prove-rs/pointer-cast-transparent-wrapper.rs new file mode 100644 index 000000000..b47544474 --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/pointer-cast-transparent-wrapper.rs @@ -0,0 +1,21 @@ +#[repr(transparent)] +#[derive(Clone, Copy)] +struct Wrapper(u32); + +fn main() { + let w = Wrapper(13); + let round_tripped = round_trip(&w); + // If the cast alignment is wrong, dereferencing `round_tripped` + // will read the inner `u32` instead of the whole `Wrapper`, + // so destructuring as `Wrapper` fails. + let Wrapper(v) = unsafe { *round_tripped }; + assert!(v == 13); +} + +fn round_trip(wrapper: &Wrapper) -> *const Wrapper { + unsafe { + let p0: *const Wrapper = wrapper; + let p1: *const u32 = p0 as *const u32; + p1 as *const Wrapper + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs b/kmir/src/tests/integration/data/prove-rs/pointer-cast-unsafe-cell.rs similarity index 100% rename from kmir/src/tests/integration/data/exec-smir/pointers/unsafe_cell_cast.rs rename to kmir/src/tests/integration/data/prove-rs/pointer-cast-unsafe-cell.rs diff --git a/kmir/src/tests/integration/data/prove-rs/reference-zero-sized.rs b/kmir/src/tests/integration/data/prove-rs/reference-zero-sized.rs new file mode 100644 index 000000000..87b00103a --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/reference-zero-sized.rs @@ -0,0 +1,7 @@ +struct Marker; + +fn main() { + let m = Marker; + let r = &m; + std::mem::drop::<&Marker>(r); +} diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected new file mode 100644 index 000000000..2a47dc97f --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected @@ -0,0 +1,15 @@ + +┌─ 1 (root, init) +│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC +│ span: 0 +│ +│ (881 steps) +└─ 3 (stuck, leaf) + #traverseProjection ( toLocal ( 3 ) , Reference ( 8 , place ( ... local: local ( + span: 836 + + +┌─ 2 (root, leaf, target, terminal) +│ #EndProgram ~> .K + + diff --git a/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected new file mode 100644 index 000000000..2953e90bb --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected @@ -0,0 +1,40 @@ + +┌─ 1 (root, init) +│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC +│ span: src/rust/library/std/src/rt.rs:194 +│ +│ (135 steps) +├─ 3 +│ #expect ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , th +│ function: read_via_cast +┃ +┃ (1 step) +┣━━┓ +┃ │ +┃ ├─ 4 +┃ │ AssertError ( assertMessageMisalignedPointerDereference ( ... required: operandC +┃ │ function: read_via_cast +┃ │ +┃ │ (1 step) +┃ └─ 6 (stuck, leaf) +┃ #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference ( ... re +┃ function: read_via_cast +┃ +┗━━┓ + │ + ├─ 5 + │ #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K + │ function: read_via_cast + │ + │ (7 steps) + └─ 7 (stuck, leaf) + #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 1 , place ( ... + function: read_via_cast + span: r/prove-rs/pointer-cast-struct-field-fail.rs:8 + + +┌─ 2 (root, leaf, target, terminal) +│ #EndProgram ~> .K + + + diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index 0357f000d..dd7820c4d 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -40,6 +40,7 @@ PROVE_RS_SHOW_SPECS = [ 'interior-mut-fail', 'interior-mut3-fail', + 'interior-mut-refcell-fail', 'assert_eq_exp', 'bitwise-not-shift', 'symbolic-args-fail', @@ -47,6 +48,7 @@ 'checked_arithmetic-fail', 'offset-u8-fail', 'pointer-cast-length-test-fail', + 'pointer-cast-struct-field-fail', 'niche-enum', 'assume-cheatcode-conflict-fail', ] @@ -259,18 +261,6 @@ def test_crate_examples(main_crate: Path, kmir: KMIR, update_expected_output: bo EXEC_DATA_DIR / 'pointers' / 'ref_ptr_cases.state', 1000, ), - ( - 'struct_cast_fail', - EXEC_DATA_DIR / 'pointers' / 'struct_cast_fail.smir.json', - EXEC_DATA_DIR / 'pointers' / 'struct_cast_fail.state', - 1000, - ), - ( - 'unsafe_cell_cast', - EXEC_DATA_DIR / 'pointers' / 'unsafe_cell_cast.smir.json', - EXEC_DATA_DIR / 'pointers' / 'unsafe_cell_cast.state', - 1000, - ), ( 'Ref-array-elem-ref', EXEC_DATA_DIR / 'references' / 'array_elem_ref.smir.json', From c25f259c572b0768ea955377fff2ae0101e9aab1 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 31 Oct 2025 18:45:45 +0800 Subject: [PATCH 13/66] chore: update test_integration.py --- kmir/src/tests/integration/test_integration.py | 1 + 1 file changed, 1 insertion(+) diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index dd7820c4d..eebf0f7bf 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -49,6 +49,7 @@ 'offset-u8-fail', 'pointer-cast-length-test-fail', 'pointer-cast-struct-field-fail', + 'pointer-cast-transparent-wrapper', 'niche-enum', 'assume-cheatcode-conflict-fail', ] From 2093f58e6f8da0dedae8ab5ddcfeb238aef02858 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Sat, 1 Nov 2025 12:20:12 +0800 Subject: [PATCH 14/66] feat: support reverse transparent struct cast --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 33 ++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 80b2201c5..34067f322 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1282,6 +1282,7 @@ which have the same representation `Value::Range`. [preserves-definedness] // valid map lookups checked syntax Place ::= #alignTransparentPlace ( Place , TypeInfo , TypeInfo ) [function, total] + syntax ProjectionElems ::= #popTransparentTailTo ( ProjectionElems , TypeInfo ) [function, total] rule #alignTransparentPlace(place(LOCAL, PROJS), typeInfoStructType(_, _, FIELD_TY .Tys, LAYOUT) #as SOURCE, TARGET) => #alignTransparentPlace( @@ -1295,8 +1296,38 @@ which have the same representation `Value::Range`. requires #transparentDepth(SOURCE) >Int #transparentDepth(TARGET) andBool #zeroFieldOffset(LAYOUT) + rule #alignTransparentPlace( + place(LOCAL, PROJS), + SOURCE, + typeInfoStructType(_, _, FIELD_TY .Tys, LAYOUT) #as TARGET + ) + => #alignTransparentPlace( + place(LOCAL, #popTransparentTailTo(PROJS, lookupTy(FIELD_TY))), + SOURCE, + lookupTy(FIELD_TY) + ) + requires #transparentDepth(SOURCE) PLACE [owise] + rule #popTransparentTailTo( + projectionElemField(fieldIdx(0), FIELD_TY) .ProjectionElems, + TARGET + ) + => .ProjectionElems + requires lookupTy(FIELD_TY) ==K TARGET + + rule #popTransparentTailTo( + X:ProjectionElem REST:ProjectionElems, + TARGET + ) + => X #popTransparentTailTo(REST, TARGET) + requires REST =/=K .ProjectionElems + + rule #popTransparentTailTo(PROJS, _) => PROJS [owise] + syntax Metadata ::= #convertMetadata ( Metadata , TypeInfo ) [function, total] // ------------------------------------------------------------------------------------- ``` @@ -1415,6 +1446,8 @@ What can be supported without additional layout consideration is trivial casts b rule #cast(PtrLocal(_, _, _, _) #as PTR, castKindTransmute, TY_SOURCE, TY_TARGET) => PTR ... requires lookupTy(TY_SOURCE) ==K lookupTy(TY_TARGET) + // Transmuting a pointer to an integer discards provenance and + // reinterprets the pointer’s offset as a value of the target integer type. rule #cast( PtrLocal(_, _, _, metadata(_, PTR_OFFSET, _)), castKindTransmute, From a313eadf1a1105b37bbc91b888b69f6bc7da38f8 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Mon, 3 Nov 2025 09:50:24 +0800 Subject: [PATCH 15/66] feat: refine transparent alignment handling --- kmir/src/kmir/kdist/mir-semantics/rt/numbers.md | 11 +++++++++++ kmir/src/tests/integration/test_integration.py | 1 - 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md b/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md index 7c9f43f38..9730b8ef1 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md @@ -148,6 +148,7 @@ This truncation function is instrumental in the implementation of Integer arithm ```k // FIXME: Alignment is platform specific +// TODO: Extend #alignOf to be total by handling aggregate layouts (structs, arrays, unions). syntax Int ::= #alignOf( TypeInfo ) [function] rule #alignOf( typeInfoPrimitiveType(primTypeBool) ) => 1 rule #alignOf( typeInfoPrimitiveType(primTypeChar) ) => 4 @@ -167,6 +168,16 @@ rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF16)) ) => 2 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF32)) ) => 4 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF64)) ) => 8 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF128)) ) => 16 + +rule #alignOf( + typeInfoStructType( + _, + _, + _, + someLayoutShape(layoutShape(_, _, _, align(ALIGN), _)) + ) + ) + => ALIGN ``` ```k diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index eebf0f7bf..dd7820c4d 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -49,7 +49,6 @@ 'offset-u8-fail', 'pointer-cast-length-test-fail', 'pointer-cast-struct-field-fail', - 'pointer-cast-transparent-wrapper', 'niche-enum', 'assume-cheatcode-conflict-fail', ] From 1057a44bb5af0b0d302f21927d10bb1e890a9822 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Mon, 3 Nov 2025 03:37:33 +0000 Subject: [PATCH 16/66] update expected output --- .../show/interior-mut3-fail.main.expected | 33 +++---------------- ...inter-cast-struct-field-fail.main.expected | 10 ++---- 2 files changed, 7 insertions(+), 36 deletions(-) diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected index d4b0127e7..80793fa28 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected @@ -3,34 +3,11 @@ │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ span: 0 │ -│ (151 steps) -├─ 3 -│ #expect ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , th -│ function: main -┃ -┃ (1 step) -┣━━┓ -┃ │ -┃ ├─ 4 -┃ │ AssertError ( assertMessageMisalignedPointerDereference ( ... required: operandC -┃ │ function: main -┃ │ -┃ │ (1 step) -┃ └─ 6 (stuck, leaf) -┃ #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference ( ... re -┃ function: main -┃ -┗━━┓ - │ - ├─ 5 - │ #execBlockIdx ( basicBlockIdx ( 8 ) ) ~> .K - │ function: main - │ - │ (8 steps) - └─ 7 (stuck, leaf) - #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 1 , place ( ... - function: main - span: 80 +│ (281 steps) +└─ 3 (stuck, leaf) + #setLocalValue ( place ( ... local: local ( 1 ) , projection: .ProjectionElems ) + function: main + span: 79 ┌─ 2 (root, leaf, target, terminal) diff --git a/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected index 2953e90bb..92eca15d1 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-struct-field-fail.main.expected @@ -1,40 +1,34 @@ ┌─ 1 (root, init) │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: src/rust/library/std/src/rt.rs:194 +│ span: 0 │ │ (135 steps) ├─ 3 │ #expect ( thunk ( #applyBinOp ( binOpEq , thunk ( #applyBinOp ( binOpBitAnd , th -│ function: read_via_cast ┃ ┃ (1 step) ┣━━┓ ┃ │ ┃ ├─ 4 ┃ │ AssertError ( assertMessageMisalignedPointerDereference ( ... required: operandC -┃ │ function: read_via_cast ┃ │ ┃ │ (1 step) ┃ └─ 6 (stuck, leaf) ┃ #ProgramError ( AssertError ( assertMessageMisalignedPointerDereference ( ... re -┃ function: read_via_cast ┃ ┗━━┓ │ ├─ 5 │ #execBlockIdx ( basicBlockIdx ( 1 ) ) ~> .K - │ function: read_via_cast │ │ (7 steps) └─ 7 (stuck, leaf) #traverseProjection ( toLocal ( 2 ) , thunk ( #cast ( PtrLocal ( 1 , place ( ... - function: read_via_cast - span: r/prove-rs/pointer-cast-struct-field-fail.rs:8 + span: 53 ┌─ 2 (root, leaf, target, terminal) │ #EndProgram ~> .K - From d3d93cac208b7bd7cc5df572b646feba8f243d7b Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 12:44:58 +0800 Subject: [PATCH 17/66] feat: solve interior-mut3-fail.rs --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 3 ++- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 9 +++++++++ .../prove-rs/{interior-mut3-fail.rs => interior-mut3.rs} | 0 kmir/src/tests/integration/test_integration.py | 1 - 4 files changed, 11 insertions(+), 2 deletions(-) rename kmir/src/tests/integration/data/prove-rs/{interior-mut3-fail.rs => interior-mut3.rs} (100%) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 34067f322..82cfe4694 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -180,7 +180,8 @@ A variant `#forceSetLocal` is provided for setting the local value without check requires 0 <=Int I andBool I #setLocalValue(place(local(I), .ProjectionElems), VAL) => .K ... diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index fa7b3522b..2dc6e5325 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -9,6 +9,7 @@ requires "value.md" module RT-TYPES imports BOOL imports INT + imports STRING imports MAP imports K-EQUAL @@ -90,6 +91,14 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #structOffsets(someLayoutShape(layoutShape(fieldsShapeArbitrary(mk(OFFSETS)), _, _, _, _))) => OFFSETS rule #structOffsets(_) => .MachineSizes [owise] + + syntax Bool ::= #allowsInteriorMutation(TypeInfo) [function, total] + + rule #allowsInteriorMutation(typeInfoStructType(mirString(NAME), _, _, _)) + => findString(NAME, "UnsafeCell", 0) =/=Int -1 + rule #allowsInteriorMutation(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "UnsafeCell", 0) =/=Int -1 + rule #allowsInteriorMutation(_) => false [owise] ``` ## Determining types of places with projection diff --git a/kmir/src/tests/integration/data/prove-rs/interior-mut3-fail.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut3.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/interior-mut3-fail.rs rename to kmir/src/tests/integration/data/prove-rs/interior-mut3.rs diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index dd7820c4d..c87c218b7 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -39,7 +39,6 @@ } PROVE_RS_SHOW_SPECS = [ 'interior-mut-fail', - 'interior-mut3-fail', 'interior-mut-refcell-fail', 'assert_eq_exp', 'bitwise-not-shift', From 8d951265ac4f43b2492a2b0f684218d89b5b20ef Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 17:07:06 +0800 Subject: [PATCH 18/66] feat: provide more information for functions without body --- kmir/src/kmir/kompile.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/kmir/src/kmir/kompile.py b/kmir/src/kmir/kompile.py index e6bcaaa33..01cb51714 100644 --- a/kmir/src/kmir/kompile.py +++ b/kmir/src/kmir/kompile.py @@ -272,6 +272,20 @@ def _functions(kmir: KMIR, smir_info: SMIRInfo) -> dict[int, KInner]: [KApply('symbol(_)_LIB_Symbol_String', [stringToken(sym['IntrinsicSym'])])], ) + # Populate remaining NormalSym entries with `noBody` shims so lookupFunction keeps the real symbol name. + for ty, sym in smir_info.function_symbols.items(): + if ty in functions or 'NormalSym' not in sym: + continue + symbol_name = sym['NormalSym'] + functions[ty] = KApply( + 'MonoItemKind::MonoItemFn', + [ + KApply('symbol(_)_LIB_Symbol_String', [stringToken(symbol_name)]), + KApply('defId(_)_BODY_DefId_Int', [intToken(ty)]), + KApply('noBody_BODY_MaybeBody', ()), + ], + ) + return functions From 46e791a5937b2547ff7939c6426ac5c6f9452e8a Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 17:47:09 +0800 Subject: [PATCH 19/66] feat(not-ready) --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 129 +++++++++++++++++- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 13 ++ kmir/src/kmir/kdist/mir-semantics/rt/types.md | 7 + 3 files changed, 147 insertions(+), 2 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 36ced69cf..c05d496b3 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -444,11 +444,136 @@ Other terminators that matter at the MIR level "Runtime" are `Drop` and `Unreach Drops are elaborated to Noops but still define the continuing control flow. Unreachable terminators lead to a program error. ```k - rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(_PLACE, TARGET, _UNWIND), _SPAN)) + syntax KItem ::= #applyDrop(MaybeTy) + | #dropValue(Value, MaybeTy) + | #releaseBorrowRefMut(Value) + | #releaseBorrowCell(Value) + | #applyBorrowCell(Int, ProjectionElems) + | #applyBorrowCellStack(Int, Int, ProjectionElems) + + rule [termDrop]: + #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) => - #execBlockIdx(TARGET) + #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) + ~> #readProjection(true) + ~> #applyDrop(getTyOf(tyOfLocal(getLocal(LOCALS, I)), PROJS)) + ~> #execBlockIdx(TARGET) ... + LOCALS + requires 0 <=Int I + andBool I VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... + + rule #dropValue(_:Value, MTY) => .K + requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) + + rule #dropValue(Aggregate(_, ARGS), MTY) + => #releaseBorrowRefMut(getValue(ARGS, 1)) + ... + + requires #isRefMutTy(#lookupMaybeTy(MTY)) + andBool 1 #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) + => #releaseBorrowCell(PTR) + ... + + + rule #releaseBorrowRefMut(_) => .K [owise] + + rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, _)) + => + #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + ~> #readProjection(false) + ~> #applyBorrowCell(J, PROJS) + ... + + LOCALS + requires 0 <=Int J + andBool J #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, _)) + => + #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + ~> #readProjection(false) + ~> #applyBorrowCell(J, PROJS) + ... + + LOCALS + requires 0 <=Int J + andBool J #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, _)) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #readProjection(false) + ~> #applyBorrowCellStack(OFFSET, J, PROJS) + ... + + STACK + requires 0 #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, _)) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #readProjection(false) + ~> #applyBorrowCellStack(OFFSET, J, PROJS) + ... + + STACK + requires 0 .K [owise] + + rule CELL:Value ~> #applyBorrowCell(J, PROJS) + => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) + ... + + + rule #applyBorrowCell(_, _) => .K [owise] + + rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #writeProjection(#incCellBorrow(CELL)) + ... + + STACK + requires 0 .K [owise] syntax MIRError ::= "ReachedUnreachable" diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 82cfe4694..7db376a92 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -347,6 +347,19 @@ These helpers mark down, as we traverse the projection, what `Place` we are curr andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid list indexing and sort checked + syntax Value ::= #incCellBorrow ( Value ) [function, total] + + rule #incCellBorrow(Integer(VAL, WIDTH, true)) + => Integer(VAL +Int 1, WIDTH, true) + requires WIDTH ==Int 64 + [preserves-definedness] + + rule #incCellBorrow(Aggregate(IDX, ListItem(FIRST) REST)) + => Aggregate(IDX, ListItem(#incCellBorrow(FIRST)) REST) + [preserves-definedness] + + rule #incCellBorrow(OTHER) => OTHER [owise] + syntax ProjectionElems ::= appendP ( ProjectionElems , ProjectionElems ) [function, total] rule appendP(.ProjectionElems, TAIL) => TAIL rule appendP(X:ProjectionElem REST:ProjectionElems, TAIL) => X appendP(REST, TAIL) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 2dc6e5325..b9b0525ab 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -99,6 +99,13 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #allowsInteriorMutation(typeInfoStructType(NAME:String, _, _, _)) => findString(NAME, "UnsafeCell", 0) =/=Int -1 rule #allowsInteriorMutation(_) => false [owise] + + syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] + + rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "RefMut<", 0) =/=Int -1 + rule #isRefMutTy(_) + => false [owise] ``` ## Determining types of places with projection From 4b3ba64bd60742723310fd5a0ba7dccf86255fdb Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 20:17:35 +0800 Subject: [PATCH 20/66] chore: interior-mut shouldn't fail with this pr --- ...ut-refcell-fail.rs => interior-mut-refcell.rs} | 0 .../{interior-mut-fail.rs => interior-mut.rs} | 0 .../prove-rs/show/interior-mut-fail.main.expected | 15 --------------- .../show/interior-mut-refcell-fail.main.expected | 15 --------------- kmir/src/tests/integration/test_integration.py | 2 -- 5 files changed, 32 deletions(-) rename kmir/src/tests/integration/data/prove-rs/{interior-mut-refcell-fail.rs => interior-mut-refcell.rs} (100%) rename kmir/src/tests/integration/data/prove-rs/{interior-mut-fail.rs => interior-mut.rs} (100%) delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected diff --git a/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell-fail.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/interior-mut-refcell-fail.rs rename to kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs diff --git a/kmir/src/tests/integration/data/prove-rs/interior-mut-fail.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut.rs similarity index 100% rename from kmir/src/tests/integration/data/prove-rs/interior-mut-fail.rs rename to kmir/src/tests/integration/data/prove-rs/interior-mut.rs diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected deleted file mode 100644 index 07ddc99a8..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-fail.main.expected +++ /dev/null @@ -1,15 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (866 steps) -└─ 3 (stuck, leaf) - #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , - span: 32 - - -┌─ 2 (root, leaf, target, terminal) -│ #EndProgram ~> .K - - diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected deleted file mode 100644 index 2a47dc97f..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut-refcell-fail.main.expected +++ /dev/null @@ -1,15 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (881 steps) -└─ 3 (stuck, leaf) - #traverseProjection ( toLocal ( 3 ) , Reference ( 8 , place ( ... local: local ( - span: 836 - - -┌─ 2 (root, leaf, target, terminal) -│ #EndProgram ~> .K - - diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index c87c218b7..a29051443 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -38,8 +38,6 @@ 'assume-cheatcode-conflict-fail': ['check_assume_conflict'], } PROVE_RS_SHOW_SPECS = [ - 'interior-mut-fail', - 'interior-mut-refcell-fail', 'assert_eq_exp', 'bitwise-not-shift', 'symbolic-args-fail', From e319042fdb6123c694caaf6a91fcf9829de377ad Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 21:20:25 +0800 Subject: [PATCH 21/66] chore: add comments --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 34 +++++++++++++++++++ kmir/src/kmir/kdist/mir-semantics/rt/data.md | 11 ++++++ kmir/src/kmir/kdist/mir-semantics/rt/types.md | 3 ++ 3 files changed, 48 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index c05d496b3..1490c5798 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -444,6 +444,23 @@ Other terminators that matter at the MIR level "Runtime" are `Drop` and `Unreach Drops are elaborated to Noops but still define the continuing control flow. Unreachable terminators lead to a program error. ```k + // Drop/borrow-release machinery for RefMut + // + // We model dropping RefMut as releasing the interior-mutability + // borrow it holds. The flow is: + // - Detect RefMut via type info (#isRefMutTy over #lookupMaybeTy). + // - Extract the pointer to the RefCell "borrow cell" from field + // index 1 of the RefMut aggregate and normalize pointer shapes. + // - Read the cell and write back #incCellBorrow(cell). With our + // convention, a unique (mutable) borrow stores -1; adding 1 + // yields 0, which corresponds to "no outstanding borrow". + // + // Notes: + // - Borrow cell is modeled as a 64-bit signed integer Value + // (see rt/data.md #incCellBorrow). + // - We do not assert the current flag equals -1; repeated drop + // would not trap in this model. + // - #isRefMutTy relies on string matching "RefMut<" (see rt/types.md). syntax KItem ::= #applyDrop(MaybeTy) | #dropValue(Value, MaybeTy) | #releaseBorrowRefMut(Value) @@ -466,11 +483,14 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid local index checked + // After reading the place value, delegate to type-directed drop rule VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... + // Non-RefMut types: no special drop behavior here rule #dropValue(_:Value, MTY) => .K requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) + // RefMut: field #1 modeled as pointer to the borrow cell rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefMut(getValue(ARGS, 1)) ... @@ -478,13 +498,18 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefMutTy(#lookupMaybeTy(MTY)) andBool 1 #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) => #releaseBorrowCell(PTR) ... + // Unknown shapes: conservatively skip rule #releaseBorrowRefMut(_) => .K [owise] + // Current-frame pointer (OFFSET = 0): read the cell and then + // apply the borrow release in the same frame rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, _)) => #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) @@ -498,6 +523,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] // valid pointer target on current stack frame + // Current-frame Reference variant: same as PtrLocal case rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, _)) => #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) @@ -511,6 +537,8 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] + // Ancestor-frame pointer (OFFSET > 0): locate the frame, read the + // cell and then apply the update in that ancestor frame rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, _)) => #traverseProjection( @@ -529,6 +557,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Ancestor-frame Reference variant: same as PtrLocal case rule #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, _)) => #traverseProjection( @@ -547,15 +576,19 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Unknown pointer shapes: skip rule #releaseBorrowCell(_) => .K [owise] + // Current-frame writeback: increment the borrow cell (e.g. -1 -> 0) rule CELL:Value ~> #applyBorrowCell(J, PROJS) => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) ... + // Fallback rule #applyBorrowCell(_, _) => .K [owise] + // Ancestor-frame writeback: increment and write back via projection rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS) => #traverseProjection( @@ -573,6 +606,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Fallback rule #applyBorrowCellStack(_, _, _) => .K [owise] syntax MIRError ::= "ReachedUnreachable" diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 7db376a92..32ec2ef2a 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -347,6 +347,16 @@ These helpers mark down, as we traverse the projection, what `Place` we are curr andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid list indexing and sort checked + // Borrow cell increment (interior mutability model) + // + // We model the RefCell borrow flag as a 64-bit signed integer Value: + // 0 -> no outstanding borrow + // >0 -> number of shared (immutable) borrows + // -1 -> unique (mutable) borrow + // Releasing a RefMut (unique borrow) applies +1 to the flag, so -1 + // becomes 0. For aggregates we recurse into the first field to reach + // the integer payload in our simplified layout model. Other Values are + // left unchanged. syntax Value ::= #incCellBorrow ( Value ) [function, total] rule #incCellBorrow(Integer(VAL, WIDTH, true)) @@ -354,6 +364,7 @@ These helpers mark down, as we traverse the projection, what `Place` we are curr requires WIDTH ==Int 64 [preserves-definedness] + // Recurse into the head field if the borrow cell is wrapped rule #incCellBorrow(Aggregate(IDX, ListItem(FIRST) REST)) => Aggregate(IDX, ListItem(#incCellBorrow(FIRST)) REST) [preserves-definedness] diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index b9b0525ab..431a47242 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -100,6 +100,9 @@ Pointers to arrays/slices are compatible with pointers to the element type => findString(NAME, "UnsafeCell", 0) =/=Int -1 rule #allowsInteriorMutation(_) => false [owise] + // Identify RefMut types conservatively by name matching. + // This is a pragmatic approximation to avoid modeling full std types. + // If the name contains "RefMut<", we treat it as RefMut. syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) From 96dc111bd3e443259fd3b9c447ff831500ad1bde Mon Sep 17 00:00:00 2001 From: Stevengre Date: Tue, 4 Nov 2025 22:34:25 +0800 Subject: [PATCH 22/66] feat: support ZSTs --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 32ec2ef2a..6aadd5b61 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -128,6 +128,13 @@ Constant operands are simply decoded according to their type. ... requires typeInfoVoidType =/=K lookupTy(TY) + + // Fallback for zero-sized constants whose type metadata was not emitted. + rule operandConstant(constOperand(_, _, mirConst(constantKindZeroSized, TY, _))) + => Aggregate(variantIdx(0), .List) + ... + + requires lookupTy(TY) ==K typeInfoVoidType ``` ### Copying and Moving @@ -1568,6 +1575,9 @@ Zero-sized types can be decoded trivially into their respective representation. // zero-sized array rule #decodeConstant(constantKindZeroSized, _TY, typeInfoArrayType(_, _)) => Range(.List) ... + // zero-sized function item (e.g., closures without captures) + rule #decodeConstant(constantKindZeroSized, _TY, typeInfoFunType(_)) + => Aggregate(variantIdx(0), .List) ... ``` Allocated constants of reference type with a single provenance map entry are decoded as references From e4b482cb0f754922cdd2bc560a99f819c3db5c71 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 09:48:49 +0800 Subject: [PATCH 23/66] chore: interior-mut3 should pass --- deps/stable-mir-json | 2 +- .../show/interior-mut3-fail.main.expected | 16 ---------------- 2 files changed, 1 insertion(+), 17 deletions(-) delete mode 100644 kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected diff --git a/deps/stable-mir-json b/deps/stable-mir-json index cf0410fba..f431082fd 160000 --- a/deps/stable-mir-json +++ b/deps/stable-mir-json @@ -1 +1 @@ -Subproject commit cf0410fba16002276f6fcdc195b7003e145558e9 +Subproject commit f431082fd2193bfc2d389e9f6b0e5771475feb0a diff --git a/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected b/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected deleted file mode 100644 index 80793fa28..000000000 --- a/kmir/src/tests/integration/data/prove-rs/show/interior-mut3-fail.main.expected +++ /dev/null @@ -1,16 +0,0 @@ - -┌─ 1 (root, init) -│ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC -│ span: 0 -│ -│ (281 steps) -└─ 3 (stuck, leaf) - #setLocalValue ( place ( ... local: local ( 1 ) , projection: .ProjectionElems ) - function: main - span: 79 - - -┌─ 2 (root, leaf, target, terminal) -│ #EndProgram ~> .K - - From 430dd93c73fd6815f20e408d1bf7f3918fed237f Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 11:22:29 +0800 Subject: [PATCH 24/66] fix: adjust stack projection writes --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 6aadd5b61..fb453e15d 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -277,7 +277,11 @@ A `Deref` projection in the projections list changes the target of the write ope STACK => STACK[(FRAME -Int 1) <- - #updateStackLocal({STACK[FRAME -Int 1]}:>StackFrame, I, #buildUpdate(NEW, CONTEXTS)) + #updateStackLocal( + {STACK[FRAME -Int 1]}:>StackFrame, + I, + #adjustRef(#buildUpdate(NEW, CONTEXTS), 0 -Int FRAME) + ) ] requires 0 STACK => STACK[(FRAME -Int 1) <- - #updateStackLocal({STACK[FRAME -Int 1]}:>StackFrame, I, #buildUpdate(Moved, CONTEXTS)) // TODO retain Ty and Mutability from _ORIGINAL + #updateStackLocal( + {STACK[FRAME -Int 1]}:>StackFrame, + I, + #adjustRef(#buildUpdate(Moved, CONTEXTS), 0 -Int FRAME) + ) // TODO retain Ty and Mutability from _ORIGINAL ] requires 0 Date: Wed, 5 Nov 2025 18:03:40 +0800 Subject: [PATCH 25/66] feat: support cast from bytes to int --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 33 ++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index fb453e15d..09040dfdb 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1519,6 +1519,26 @@ The first cast is reified as a `thunk`, the second one resolves it and eliminate requires lookupTy(TY_SRC_INNER) ==K lookupTy(TY_DEST_OUTER) // cast is a round-trip andBool lookupTy(TY_DEST_INNER) ==K lookupTy(TY_SRC_OUTER) // and is well-formed (invariant) + + // Casting a byte array/slice to an integer reinterprets the bytes in little-endian order. + rule #cast( + Range(ELEMS), + castKindTransmute, + _TY_SOURCE, + TY_TARGET + ) + => + #intAsType( + #littleEndianFromBytes(ELEMS), + size(ELEMS) *Int 8, + #numTypeOf(lookupTy(TY_TARGET)) + ) + ... + + requires #isIntType(lookupTy(TY_TARGET)) + andBool size(ELEMS) *Int 8 ==Int #bitWidth(#numTypeOf(lookupTy(TY_TARGET))) + andBool #areLittleEndianBytes(ELEMS) + [preserves-definedness] // ensures #numTypeOf is defined ``` Another specialisation is getting the discriminant of `enum`s without fields after converting some integer data to it @@ -1538,6 +1558,19 @@ If none of the `enum` variants has any fields, the `Transmute` of a number to th // ---------------------------------------------------------------- rule #isEnumWithoutFields(typeInfoEnumType(_, _, _, FIELDSS, _)) => #noFields(FIELDSS) rule #isEnumWithoutFields(_OTHER) => false [owise] + + syntax Bool ::= #areLittleEndianBytes ( List ) [function, total] + // ------------------------------------------------------------- + rule #areLittleEndianBytes(.List) => true + rule #areLittleEndianBytes(ListItem(Integer(_, 8, false)) REST) + => #areLittleEndianBytes(REST) + rule #areLittleEndianBytes(ListItem(_OTHER) _) => false [owise] + + syntax Int ::= #littleEndianFromBytes ( List ) [function] + // ----------------------------------------------------- + rule #littleEndianFromBytes(.List) => 0 + rule #littleEndianFromBytes(ListItem(Integer(BYTE, 8, false)) REST) + => BYTE +Int 256 *Int #littleEndianFromBytes(REST) ``` From e5f30b7c077a00818675570ced90323fa9f4e73e Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 18:17:31 +0800 Subject: [PATCH 26/66] feat: support ref borrow (need to optimize) --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 121 +++++++++++++++++- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 14 ++ kmir/src/kmir/kdist/mir-semantics/rt/types.md | 8 ++ 3 files changed, 139 insertions(+), 4 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 1490c5798..35ecd30e5 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -464,9 +464,13 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre syntax KItem ::= #applyDrop(MaybeTy) | #dropValue(Value, MaybeTy) | #releaseBorrowRefMut(Value) + | #releaseBorrowRefShared(Value) | #releaseBorrowCell(Value) + | #releaseBorrowCellShared(Value) | #applyBorrowCell(Int, ProjectionElems) + | #applyBorrowCellShared(Int, ProjectionElems) | #applyBorrowCellStack(Int, Int, ProjectionElems) + | #applyBorrowCellStackShared(Int, Int, ProjectionElems) rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) @@ -486,10 +490,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // After reading the place value, delegate to type-directed drop rule VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... - // Non-RefMut types: no special drop behavior here - rule #dropValue(_:Value, MTY) => .K - requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) - // RefMut: field #1 modeled as pointer to the borrow cell rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefMut(getValue(ARGS, 1)) @@ -498,6 +498,19 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefMutTy(#lookupMaybeTy(MTY)) andBool 1 : field #1 stores the shared borrow token that points to the borrow cell. + rule #dropValue(Aggregate(_, ARGS), MTY) + => #releaseBorrowRefShared(getValue(ARGS, 1)) + ... + + requires #isRefTy(#lookupMaybeTy(MTY)) + andBool 1 .K + requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) + andBool notBool #isRefTy(#lookupMaybeTy(MTY)) + // Accept either Reference/PtrLocal inside the RefMut wrapper // and forward to the release operation rule #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) @@ -508,6 +521,14 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // Unknown shapes: conservatively skip rule #releaseBorrowRefMut(_) => .K [owise] + // Shared borrow release mirrors the RefMut case but decrements the borrow cell. + rule #releaseBorrowRefShared(Aggregate(_, ListItem(PTR) _)) + => #releaseBorrowCellShared(PTR) + ... + + + rule #releaseBorrowRefShared(_) => .K [owise] + // Current-frame pointer (OFFSET = 0): read the cell and then // apply the borrow release in the same frame rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, _)) @@ -579,6 +600,71 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // Unknown pointer shapes: skip rule #releaseBorrowCell(_) => .K [owise] + // Shared borrow release: same traversal but uses #decCellBorrow on writeback. + rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, _)) + => + #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + ~> #readProjection(false) + ~> #applyBorrowCellShared(J, PROJS) + ... + + LOCALS + requires 0 <=Int J + andBool J #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, _)) + => + #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + ~> #readProjection(false) + ~> #applyBorrowCellShared(J, PROJS) + ... + + LOCALS + requires 0 <=Int J + andBool J #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, _)) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #readProjection(false) + ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + ... + + STACK + requires 0 #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, _)) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #readProjection(false) + ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + ... + + STACK + requires 0 .K [owise] + // Current-frame writeback: increment the borrow cell (e.g. -1 -> 0) rule CELL:Value ~> #applyBorrowCell(J, PROJS) => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) @@ -609,6 +695,33 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // Fallback rule #applyBorrowCellStack(_, _, _) => .K [owise] + // Shared borrow writeback helpers apply #decCellBorrow instead. + rule CELL:Value ~> #applyBorrowCellShared(J, PROJS) + => #setLocalValue(place(local(J), PROJS), #decCellBorrow(CELL)) + ... + + + rule #applyBorrowCellShared(_, _) => .K [owise] + + rule CELL:Value ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + => + #traverseProjection( + toStack(OFFSET, local(J)), + #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), + PROJS, + .Contexts + ) + ~> #writeProjection(#decCellBorrow(CELL)) + ... + + STACK + requires 0 .K [owise] + syntax MIRError ::= "ReachedUnreachable" rule [termUnreachable]: #execTerminator(terminator(terminatorKindUnreachable, _SPAN)) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 09040dfdb..a30fd9ed1 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -386,6 +386,20 @@ These helpers mark down, as we traverse the projection, what `Place` we are curr rule #incCellBorrow(OTHER) => OTHER [owise] + // Borrow cell decrement for releasing shared Ref borrows. + syntax Value ::= #decCellBorrow ( Value ) [function, total] + + rule #decCellBorrow(Integer(VAL, WIDTH, true)) + => Integer(VAL -Int 1, WIDTH, true) + requires WIDTH ==Int 64 + [preserves-definedness] + + rule #decCellBorrow(Aggregate(IDX, ListItem(FIRST) REST)) + => Aggregate(IDX, ListItem(#decCellBorrow(FIRST)) REST) + [preserves-definedness] + + rule #decCellBorrow(OTHER) => OTHER [owise] + syntax ProjectionElems ::= appendP ( ProjectionElems , ProjectionElems ) [function, total] rule appendP(.ProjectionElems, TAIL) => TAIL rule appendP(X:ProjectionElem REST:ProjectionElems, TAIL) => X appendP(REST, TAIL) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 431a47242..c4a02da6c 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -109,6 +109,14 @@ Pointers to arrays/slices are compatible with pointers to the element type => findString(NAME, "RefMut<", 0) =/=Int -1 rule #isRefMutTy(_) => false [owise] + + // Identify Ref (shared borrow) types while excluding RefMut. + syntax Bool ::= #isRefTy ( TypeInfo ) [function, total] + + rule #isRefTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "Ref<", 0) =/=Int -1 + andBool findString(NAME, "RefMut<", 0) ==Int -1 + rule #isRefTy(_) => false [owise] ``` ## Determining types of places with projection From 0a78baeda05ad4f27ba04f8b9e41419f9f9bd698 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 18:58:18 +0800 Subject: [PATCH 27/66] feat: support cast from int to bytes --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 29 ++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index a30fd9ed1..f80ee3ef6 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1553,6 +1553,19 @@ The first cast is reified as a `thunk`, the second one resolves it and eliminate andBool size(ELEMS) *Int 8 ==Int #bitWidth(#numTypeOf(lookupTy(TY_TARGET))) andBool #areLittleEndianBytes(ELEMS) [preserves-definedness] // ensures #numTypeOf is defined + + // Casting an integer to a `[u8; N]` array materialises its little-endian bytes. + rule #cast( + Integer(VAL, WIDTH, _SIGNEDNESS), + castKindTransmute, + _TY_SOURCE, + _TY_TARGET + ) + => + Range(#littleEndianBytesFromInt(VAL, WIDTH)) + ... + + [preserves-definedness] // ensures element type/length are well-formed ``` Another specialisation is getting the discriminant of `enum`s without fields after converting some integer data to it @@ -1585,6 +1598,22 @@ If none of the `enum` variants has any fields, the `Transmute` of a number to th rule #littleEndianFromBytes(.List) => 0 rule #littleEndianFromBytes(ListItem(Integer(BYTE, 8, false)) REST) => BYTE +Int 256 *Int #littleEndianFromBytes(REST) + + syntax List ::= #littleEndianBytesFromInt ( Int, Int ) [function] + | #littleEndianBytes ( Int, Int ) [function] + // ------------------------------------------------------------- + rule #littleEndianBytesFromInt(VAL, WIDTH) + => #littleEndianBytes(truncate(VAL, WIDTH, Unsigned), WIDTH /Int 8) + requires WIDTH %Int 8 ==Int 0 + andBool WIDTH >=Int 0 + + rule #littleEndianBytes(_, COUNT) + => .List + requires COUNT <=Int 0 + + rule #littleEndianBytes(VAL, COUNT) + => ListItem(Integer(VAL %Int 256, 8, false)) #littleEndianBytes(VAL /Int 256, COUNT -Int 1) + requires COUNT >Int 0 ``` From d0c1793715a5b3a8dc7a8066aa44152a920c9237 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 19:04:31 +0800 Subject: [PATCH 28/66] restore stable-mir-json --- deps/stable-mir-json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deps/stable-mir-json b/deps/stable-mir-json index f431082fd..cf0410fba 160000 --- a/deps/stable-mir-json +++ b/deps/stable-mir-json @@ -1 +1 @@ -Subproject commit f431082fd2193bfc2d389e9f6b0e5771475feb0a +Subproject commit cf0410fba16002276f6fcdc195b7003e145558e9 From 08389d0a2e74c48cdd54527edd518f836ba56587 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 19:08:22 +0800 Subject: [PATCH 29/66] chore: format --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index f80ee3ef6..3c3ee56c2 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -134,7 +134,7 @@ Constant operands are simply decoded according to their type. => Aggregate(variantIdx(0), .List) ... - requires lookupTy(TY) ==K typeInfoVoidType + requires typeInfoVoidType ==K lookupTy(TY) ``` ### Copying and Moving From 2e1aeb1d2f0b49605cb9305fd116bc146f9a2199 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 20:15:16 +0800 Subject: [PATCH 30/66] feat: add #withPointerOffset to support projections' pointer offset --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 74 +++++++++++++++-------- 1 file changed, 50 insertions(+), 24 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 35ecd30e5..159807a18 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -472,6 +472,12 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre | #applyBorrowCellStack(Int, Int, ProjectionElems) | #applyBorrowCellStackShared(Int, Int, ProjectionElems) + syntax ProjectionElems ::= #withPointerOffset(ProjectionElems, Int, MetadataSize) [function, total] + rule #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE) + => appendP(PROJS, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))) + requires PTR_OFFSET =/=Int 0 + rule #withPointerOffset(PROJS, _PTR_OFFSET, _ORIGIN_SIZE) => PROJS [owise] + rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) => @@ -531,11 +537,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // Current-frame pointer (OFFSET = 0): read the cell and then // apply the borrow release in the same frame - rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, _)) + rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => - #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + #traverseProjection( + toLocal(J), + getValue(LOCALS, J), + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), + .Contexts + ) ~> #readProjection(false) - ~> #applyBorrowCell(J, PROJS) + ~> #applyBorrowCell(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... LOCALS @@ -545,11 +556,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre [preserves-definedness] // valid pointer target on current stack frame // Current-frame Reference variant: same as PtrLocal case - rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, _)) + rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => - #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + #traverseProjection( + toLocal(J), + getValue(LOCALS, J), + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), + .Contexts + ) ~> #readProjection(false) - ~> #applyBorrowCell(J, PROJS) + ~> #applyBorrowCell(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... LOCALS @@ -560,16 +576,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // Ancestor-frame pointer (OFFSET > 0): locate the frame, read the // cell and then apply the update in that ancestor frame - rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, _)) + rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( toStack(OFFSET, local(J)), #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - PROJS, + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCellStack(OFFSET, J, PROJS) + ~> #applyBorrowCellStack(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... STACK @@ -579,16 +595,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre [preserves-definedness] // Ancestor-frame Reference variant: same as PtrLocal case - rule #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, _)) + rule #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( toStack(OFFSET, local(J)), #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - PROJS, + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCellStack(OFFSET, J, PROJS) + ~> #applyBorrowCellStack(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... STACK @@ -601,11 +617,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre rule #releaseBorrowCell(_) => .K [owise] // Shared borrow release: same traversal but uses #decCellBorrow on writeback. - rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, _)) + rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => - #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + #traverseProjection( + toLocal(J), + getValue(LOCALS, J), + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), + .Contexts + ) ~> #readProjection(false) - ~> #applyBorrowCellShared(J, PROJS) + ~> #applyBorrowCellShared(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... LOCALS @@ -614,11 +635,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - rule #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, _)) + rule #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => - #traverseProjection(toLocal(J), getValue(LOCALS, J), PROJS, .Contexts) + #traverseProjection( + toLocal(J), + getValue(LOCALS, J), + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), + .Contexts + ) ~> #readProjection(false) - ~> #applyBorrowCellShared(J, PROJS) + ~> #applyBorrowCellShared(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... LOCALS @@ -627,16 +653,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - rule #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, _)) + rule #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( toStack(OFFSET, local(J)), #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - PROJS, + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + ~> #applyBorrowCellStackShared(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... STACK @@ -645,16 +671,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - rule #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, _)) + rule #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( toStack(OFFSET, local(J)), #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - PROJS, + #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + ~> #applyBorrowCellStackShared(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) ... STACK From 1b24944ece414060458b270dfc80a44fe3b755b6 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 20:19:38 +0800 Subject: [PATCH 31/66] feat: enhance interior mutability handling in projections --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 3c3ee56c2..9e148c327 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -187,8 +187,7 @@ A variant `#forceSetLocal` is provided for setting the local value without check requires 0 <=Int I andBool I #setLocalValue(place(local(I), .ProjectionElems), VAL) => .K ... @@ -256,6 +255,19 @@ A `Deref` projection in the projections list changes the target of the write ope rule #traverseProjection(_, VAL, .ProjectionElems, _) ~> #readProjection(false) => VAL ... rule #traverseProjection(_, VAL, .ProjectionElems, _) ~> (#readProjection(true) => #writeMoved ~> VAL) ... + // interior mutability permits projected writeback + rule #traverseProjection(toLocal(I), _ORIGINAL, .ProjectionElems, CONTEXTS) + ~> #writeProjection(NEW) + => #forceSetLocal(local(I), #buildUpdate(NEW, CONTEXTS)) + ... + + LOCALS + requires CONTEXTS =/=K .Contexts + andBool 0 <=Int I andBool I TypedLocal))) + [priority(40), preserves-definedness] + rule #traverseProjection(toLocal(I), _ORIGINAL, .ProjectionElems, CONTEXTS) ~> #writeProjection(NEW) => #setLocalValue(place(local(I), .ProjectionElems), #buildUpdate(NEW, CONTEXTS)) From 5ca54b5978e9f8912d02b0fff2e649536800cc2e Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 20:41:53 +0800 Subject: [PATCH 32/66] refactor: remove unused NormalSym population logic in _functions --- kmir/src/kmir/kompile.py | 14 -------------- ...mbolic-args-fail.main.cli-stats-leaves.expected | 4 ++-- 2 files changed, 2 insertions(+), 16 deletions(-) diff --git a/kmir/src/kmir/kompile.py b/kmir/src/kmir/kompile.py index 01cb51714..e6bcaaa33 100644 --- a/kmir/src/kmir/kompile.py +++ b/kmir/src/kmir/kompile.py @@ -272,20 +272,6 @@ def _functions(kmir: KMIR, smir_info: SMIRInfo) -> dict[int, KInner]: [KApply('symbol(_)_LIB_Symbol_String', [stringToken(sym['IntrinsicSym'])])], ) - # Populate remaining NormalSym entries with `noBody` shims so lookupFunction keeps the real symbol name. - for ty, sym in smir_info.function_symbols.items(): - if ty in functions or 'NormalSym' not in sym: - continue - symbol_name = sym['NormalSym'] - functions[ty] = KApply( - 'MonoItemKind::MonoItemFn', - [ - KApply('symbol(_)_LIB_Symbol_String', [stringToken(symbol_name)]), - KApply('defId(_)_BODY_DefId_Int', [intToken(ty)]), - KApply('noBody_BODY_MaybeBody', ()), - ], - ) - return functions diff --git a/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected b/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected index 8dd5ab168..de1f5fd22 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected @@ -5,7 +5,7 @@ │ │ (563 steps) └─ 3 (stuck, leaf) - #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , + #setUpCalleeData ( monoItemFn ( ... name: symbol ( "_ZN4core9panicking5panic17h3 span: no-location:0 @@ -32,4 +32,4 @@ Leaf paths from init: LEAF CELLS --------------- Node 3: - #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , id: defId ( 38 ) , body: noBody ) , operandConstant ( constOperand ( ... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst ( ... kind: constantKindAllocated ( allocation ( ... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap ( ... ptrs: provenanceMapEntry ( ... offset: 0 , allocId: allocId ( 1 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 39 ) , id: mirConstId ( 25 ) ) ) ) .Operands ) ~> .K \ No newline at end of file + #setUpCalleeData ( monoItemFn ( ... name: symbol ( "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" ) , id: defId ( 38 ) , body: noBody ) , operandConstant ( constOperand ( ... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst ( ... kind: constantKindAllocated ( allocation ( ... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap ( ... ptrs: provenanceMapEntry ( ... offset: 0 , allocId: allocId ( 1 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 39 ) , id: mirConstId ( 25 ) ) ) ) .Operands ) ~> .K \ No newline at end of file From 4683341bd38e28aaf2e2196c231ff05b6a5c30cc Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 20:51:19 +0800 Subject: [PATCH 33/66] feat: simplify borrow cell increment and decrement logic for interior mutability --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 9e148c327..d46b144f9 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -374,42 +374,26 @@ These helpers mark down, as we traverse the projection, what `Place` we are curr andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid list indexing and sort checked - // Borrow cell increment (interior mutability model) - // - // We model the RefCell borrow flag as a 64-bit signed integer Value: - // 0 -> no outstanding borrow - // >0 -> number of shared (immutable) borrows - // -1 -> unique (mutable) borrow - // Releasing a RefMut (unique borrow) applies +1 to the flag, so -1 - // becomes 0. For aggregates we recurse into the first field to reach - // the integer payload in our simplified layout model. Other Values are - // left unchanged. + // Borrow cell increment (interior mutability model) for shared Ref borrows. syntax Value ::= #incCellBorrow ( Value ) [function, total] - rule #incCellBorrow(Integer(VAL, WIDTH, true)) => Integer(VAL +Int 1, WIDTH, true) requires WIDTH ==Int 64 [preserves-definedness] - - // Recurse into the head field if the borrow cell is wrapped rule #incCellBorrow(Aggregate(IDX, ListItem(FIRST) REST)) => Aggregate(IDX, ListItem(#incCellBorrow(FIRST)) REST) [preserves-definedness] - rule #incCellBorrow(OTHER) => OTHER [owise] // Borrow cell decrement for releasing shared Ref borrows. syntax Value ::= #decCellBorrow ( Value ) [function, total] - rule #decCellBorrow(Integer(VAL, WIDTH, true)) => Integer(VAL -Int 1, WIDTH, true) requires WIDTH ==Int 64 [preserves-definedness] - rule #decCellBorrow(Aggregate(IDX, ListItem(FIRST) REST)) => Aggregate(IDX, ListItem(#decCellBorrow(FIRST)) REST) [preserves-definedness] - rule #decCellBorrow(OTHER) => OTHER [owise] syntax ProjectionElems ::= appendP ( ProjectionElems , ProjectionElems ) [function, total] From a8b3258e074cf6cc3d43dcd769219225925604b3 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 21:01:10 +0800 Subject: [PATCH 34/66] feat: add handling for pointer realignment across transparent wrappers in casts --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index d46b144f9..2bd59e051 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1313,6 +1313,13 @@ the `Value` sort. Conversion is especially possible for the case of _Slices_ (of dynamic length) and _Arrays_ (of static length), which have the same representation `Value::Range`. +When the cast crosses transparent wrappers (for example newtypes that just forward field `0`), the pointer's +`Place` must be realigned. `#alignTransparentPlace` rewrites the projection list until the source and target +expose the same inner value: +- if the source unwraps more than the target, append an explicit `field(0)` so the target still sees that field; +- if the target unwraps more, strip any redundant tail projections with `#popTransparentTailTo`, leaving the + canonical prefix shared by both sides. + ```k rule #cast(PtrLocal(OFFSET, PLACE, MUT, META), castKindPtrToPtr, TY_SOURCE, TY_TARGET) => From f1c30059112e2f7c87fede1ec90c91a7bb6dc836 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 21:13:05 +0800 Subject: [PATCH 35/66] feat: initialize zero-sized locals for borrowing to ensure projection traversal succeeds --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 2bd59e051..aca81256b 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1119,10 +1119,10 @@ This eliminates any `Deref` projections from the place, and also resolves `Index // rule #projectionsFor(CtxPointerOffset(OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, projectionElemSubslice(OFFSET, ORIGIN_LENGTH, false) PROJS) rule #projectionsFor(CtxPointerOffset( _, OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, PointerOffset(OFFSET, ORIGIN_LENGTH) PROJS) - // Borrowing a zero-sized local that is still `NewLocal`: materialise a dummy ZST value so projection traversal succeeds without reading uninitialised data. - rule rvalueRef(_REGION, KIND, place(local(I), PROJS)) - => #traverseProjection(toLocal(I), Aggregate(variantIdx(0), .List), PROJS, .Contexts) - ~> #forRef(#mutabilityOf(KIND), metadata(noMetadataSize, 0, noMetadataSize)) + // Borrowing a zero-sized local that is still `NewLocal`: initialise it, then reuse the regular rule. + rule rvalueRef(REGION, KIND, place(local(I), PROJS)) + => #forceSetLocal(local(I), Aggregate(variantIdx(0), .List)) + ~> rvalueRef(REGION, KIND, place(local(I), PROJS)) ... LOCALS From d94197bd06ca3762f398b8e1e9d2b68d39e3b09c Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 21:17:12 +0800 Subject: [PATCH 36/66] feat: streamline alignment rule for struct types in #alignOf function --- kmir/src/kmir/kdist/mir-semantics/rt/numbers.md | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md b/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md index 9730b8ef1..9a56ecd11 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/numbers.md @@ -168,16 +168,7 @@ rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF16)) ) => 2 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF32)) ) => 4 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF64)) ) => 8 rule #alignOf( typeInfoPrimitiveType(primTypeFloat(floatTyF128)) ) => 16 - -rule #alignOf( - typeInfoStructType( - _, - _, - _, - someLayoutShape(layoutShape(_, _, _, align(ALIGN), _)) - ) - ) - => ALIGN +rule #alignOf( typeInfoStructType(_,_,_,someLayoutShape(layoutShape(_, _, _, align(ALIGN), _)))) => ALIGN ``` ```k From d45a24a69954ccd6287232fee2a7f3573239007c Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 21:25:17 +0800 Subject: [PATCH 37/66] feat: update expected output for pointer cast length test and symbolic args failure --- .../pointer-cast-length-test-fail.array_cast_test.expected | 4 ++-- .../show/symbolic-args-fail.main.cli-stats-leaves.expected | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-length-test-fail.array_cast_test.expected b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-length-test-fail.array_cast_test.expected index ff6808691..2688fd0d2 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-length-test-fail.array_cast_test.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/pointer-cast-length-test-fail.array_cast_test.expected @@ -41,7 +41,7 @@ ┃ │ ┃ │ (6 steps) ┃ ├─ 10 - ┃ │ #traverseProjection ( toStack ( 1 , local ( 2 ) ) , Range ( #mapOffset ( range ( + ┃ │ #traverseProjection ( toStack ( 1 , local ( 2 ) ) , Range ( #mapOffset ( #mapOff ┃ │ span: 87 ┃ ┃ ┃ ┃ (1 step) @@ -59,7 +59,7 @@ ┃ ┗━━┓ ┃ │ ┃ └─ 12 (stuck, leaf) - ┃ #traverseProjection ( toStack ( 1 , local ( 2 ) ) , Range ( #mapOffset ( range ( + ┃ #traverseProjection ( toStack ( 1 , local ( 2 ) ) , Range ( #mapOffset ( #mapOff ┃ span: 87 ┃ ┗━━┓ diff --git a/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected b/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected index de1f5fd22..8dd5ab168 100644 --- a/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected +++ b/kmir/src/tests/integration/data/prove-rs/show/symbolic-args-fail.main.cli-stats-leaves.expected @@ -5,7 +5,7 @@ │ │ (563 steps) └─ 3 (stuck, leaf) - #setUpCalleeData ( monoItemFn ( ... name: symbol ( "_ZN4core9panicking5panic17h3 + #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , span: no-location:0 @@ -32,4 +32,4 @@ Leaf paths from init: LEAF CELLS --------------- Node 3: - #setUpCalleeData ( monoItemFn ( ... name: symbol ( "_ZN4core9panicking5panic17h37379bf3ce79a0d7E" ) , id: defId ( 38 ) , body: noBody ) , operandConstant ( constOperand ( ... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst ( ... kind: constantKindAllocated ( allocation ( ... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap ( ... ptrs: provenanceMapEntry ( ... offset: 0 , allocId: allocId ( 1 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 39 ) , id: mirConstId ( 25 ) ) ) ) .Operands ) ~> .K \ No newline at end of file + #setUpCalleeData ( monoItemFn ( ... name: symbol ( "** UNKNOWN FUNCTION **" ) , id: defId ( 38 ) , body: noBody ) , operandConstant ( constOperand ( ... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst ( ... kind: constantKindAllocated ( allocation ( ... bytes: b"\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap ( ... ptrs: provenanceMapEntry ( ... offset: 0 , allocId: allocId ( 1 ) ) .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 39 ) , id: mirConstId ( 25 ) ) ) ) .Operands ) ~> .K \ No newline at end of file From 69a4efd922b23e1ab57f5f8ec8c254aaec6ab3d8 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 22:07:08 +0800 Subject: [PATCH 38/66] feat: add comment for pointer transmutation test and correctness check --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index aca81256b..c0f094967 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1505,6 +1505,8 @@ What can be supported without additional layout consideration is trivial casts b // Transmuting a pointer to an integer discards provenance and // reinterprets the pointer’s offset as a value of the target integer type. + // Tested by `prove-rs/interior-mut3.rs` + // TODO: check its correctness, I assume the pointer offset is the address here and we can use it to recover the PtrLocal rule #cast( PtrLocal(_, _, _, metadata(_, PTR_OFFSET, _)), castKindTransmute, From eb837427f65a9873de96fa2bacea6744b485a7ca Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 22:24:47 +0800 Subject: [PATCH 39/66] feat: add static array checks for transmute operations in MIR execution --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index c0f094967..f242be65e 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1564,12 +1564,16 @@ The first cast is reified as a `thunk`, the second one resolves it and eliminate Integer(VAL, WIDTH, _SIGNEDNESS), castKindTransmute, _TY_SOURCE, - _TY_TARGET + TY_TARGET ) => Range(#littleEndianBytesFromInt(VAL, WIDTH)) ... + requires #isStaticU8Array(lookupTy(TY_TARGET)) + andBool WIDTH >=Int 0 + andBool WIDTH %Int 8 ==Int 0 + andBool WIDTH ==Int #staticArrayLenBits(lookupTy(TY_TARGET)) [preserves-definedness] // ensures element type/length are well-formed ``` @@ -1619,6 +1623,19 @@ If none of the `enum` variants has any fields, the `Transmute` of a number to th rule #littleEndianBytes(VAL, COUNT) => ListItem(Integer(VAL %Int 256, 8, false)) #littleEndianBytes(VAL /Int 256, COUNT -Int 1) requires COUNT >Int 0 + + syntax Bool ::= #isStaticU8Array ( TypeInfo ) [function, total] + // ------------------------------------------------------------- + rule #isStaticU8Array(typeInfoArrayType(ELEM_TY, someTyConst(_))) + => lookupTy(ELEM_TY) ==K typeInfoPrimitiveType(primTypeUint(uintTyU8)) + rule #isStaticU8Array(_OTHER) => false [owise] + + syntax Int ::= #staticArrayLenBits ( TypeInfo ) [function, total] + // ------------------------------------------------------------- + rule #staticArrayLenBits(typeInfoArrayType(_, someTyConst(tyConst(KIND, _)))) + => readTyConstInt(KIND) *Int 8 + [preserves-definedness] + rule #staticArrayLenBits(_OTHER) => 0 [owise] ``` From b13b312abda97a3bc15b4f2d2e8e44d7e81c77e1 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 22:36:35 +0800 Subject: [PATCH 40/66] feat: refactor type identification for Ref and RefMut in type metadata --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 16 +++++++++++++++- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 17 ----------------- 2 files changed, 15 insertions(+), 18 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 159807a18..103f856b1 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -460,7 +460,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // (see rt/data.md #incCellBorrow). // - We do not assert the current flag equals -1; repeated drop // would not trap in this model. - // - #isRefMutTy relies on string matching "RefMut<" (see rt/types.md). + // - #isRefMutTy relies on string matching "RefMut<" (defined below). syntax KItem ::= #applyDrop(MaybeTy) | #dropValue(Value, MaybeTy) | #releaseBorrowRefMut(Value) @@ -496,6 +496,20 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // After reading the place value, delegate to type-directed drop rule VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... + // Identify Ref/RefMut via string matching; drop currently only needs these helpers. + syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] + + rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "RefMut<", 0) =/=Int -1 + rule #isRefMutTy(_) => false [owise] + + syntax Bool ::= #isRefTy ( TypeInfo ) [function, total] + + rule #isRefTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "Ref<", 0) =/=Int -1 + andBool findString(NAME, "RefMut<", 0) ==Int -1 + rule #isRefTy(_) => false [owise] + // RefMut: field #1 modeled as pointer to the borrow cell rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefMut(getValue(ARGS, 1)) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index c4a02da6c..7325ad8a3 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -100,23 +100,6 @@ Pointers to arrays/slices are compatible with pointers to the element type => findString(NAME, "UnsafeCell", 0) =/=Int -1 rule #allowsInteriorMutation(_) => false [owise] - // Identify RefMut types conservatively by name matching. - // This is a pragmatic approximation to avoid modeling full std types. - // If the name contains "RefMut<", we treat it as RefMut. - syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] - - rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) - => findString(NAME, "RefMut<", 0) =/=Int -1 - rule #isRefMutTy(_) - => false [owise] - - // Identify Ref (shared borrow) types while excluding RefMut. - syntax Bool ::= #isRefTy ( TypeInfo ) [function, total] - - rule #isRefTy(typeInfoStructType(NAME:String, _, _, _)) - => findString(NAME, "Ref<", 0) =/=Int -1 - andBool findString(NAME, "RefMut<", 0) ==Int -1 - rule #isRefTy(_) => false [owise] ``` ## Determining types of places with projection From d3b81e19269e5a97361929afa0b1065efa5a984d Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 22:50:18 +0800 Subject: [PATCH 41/66] feat: update expected step count in crate2::test_crate1_with test --- .../two-crate-dylib/crate2::test_crate1_with.expected | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected b/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected index 9c905f5d3..bdade977c 100644 --- a/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected +++ b/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected @@ -2,7 +2,7 @@ ┌─ 1 (root, init) │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ -│ (212 steps) +│ (217 steps) ├─ 3 (terminal) │ #EndProgram ~> .K │ From 716dc167bf9274d53dfdbd789f796870f0e0ef33 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 23:01:05 +0800 Subject: [PATCH 42/66] feat: refine drop semantics and enhance comments for clarity --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 77 ++++++++++++----------- 1 file changed, 42 insertions(+), 35 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 103f856b1..8256a2954 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -461,6 +461,23 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre // - We do not assert the current flag equals -1; repeated drop // would not trap in this model. // - #isRefMutTy relies on string matching "RefMut<" (defined below). + + rule [termDrop]: + #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) + => + #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) + ~> #readProjection(true) + ~> #applyDrop(getTyOf(tyOfLocal(getLocal(LOCALS, I)), PROJS)) + ~> #execBlockIdx(TARGET) + ... + + LOCALS + requires 0 <=Int I + andBool I PROJS [owise] - rule [termDrop]: - #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) - => - #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) - ~> #readProjection(true) - ~> #applyDrop(getTyOf(tyOfLocal(getLocal(LOCALS, I)), PROJS)) - ~> #execBlockIdx(TARGET) - ... - - LOCALS - requires 0 <=Int I - andBool I VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... @@ -510,7 +512,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool findString(NAME, "RefMut<", 0) ==Int -1 rule #isRefTy(_) => false [owise] - // RefMut: field #1 modeled as pointer to the borrow cell + // Case: RefMut -> field #1 holds the borrow cell pointer rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefMut(getValue(ARGS, 1)) ... @@ -518,7 +520,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefMutTy(#lookupMaybeTy(MTY)) andBool 1 : field #1 stores the shared borrow token that points to the borrow cell. + // Case: Ref -> field #1 stores the shared borrow token pointing to the borrow cell rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefShared(getValue(ARGS, 1)) ... @@ -526,31 +528,30 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefTy(#lookupMaybeTy(MTY)) andBool 1 no special drop behavior rule #dropValue(_:Value, MTY) => .K requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) andBool notBool #isRefTy(#lookupMaybeTy(MTY)) - // Accept either Reference/PtrLocal inside the RefMut wrapper - // and forward to the release operation + // Case: RefMut wrapper contains Reference/PtrLocal -> forward to release rule #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) => #releaseBorrowCell(PTR) ... - // Unknown shapes: conservatively skip + // Fallback case: unknown RefMut shapes -> skip rule #releaseBorrowRefMut(_) => .K [owise] - // Shared borrow release mirrors the RefMut case but decrements the borrow cell. + // Case: Ref aggregate -> release shared borrow by decrementing the cell rule #releaseBorrowRefShared(Aggregate(_, ListItem(PTR) _)) => #releaseBorrowCellShared(PTR) ... + // Fallback case: unknown Ref shapes -> skip rule #releaseBorrowRefShared(_) => .K [owise] - // Current-frame pointer (OFFSET = 0): read the cell and then - // apply the borrow release in the same frame + // Case: current-frame PtrLocal (OFFSET = 0) -> read cell and release in place rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -569,7 +570,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] // valid pointer target on current stack frame - // Current-frame Reference variant: same as PtrLocal case + // Case: current-frame Reference variant -> mirror PtrLocal handling rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -588,8 +589,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - // Ancestor-frame pointer (OFFSET > 0): locate the frame, read the - // cell and then apply the update in that ancestor frame + // Case: ancestor-frame PtrLocal (OFFSET > 0) -> traverse stack frame and release rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -608,7 +608,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Ancestor-frame Reference variant: same as PtrLocal case + // Case: ancestor-frame Reference variant -> mirror PtrLocal handling rule #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -627,10 +627,10 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Unknown pointer shapes: skip + // Fallback case: unknown pointer shapes -> skip rule #releaseBorrowCell(_) => .K [owise] - // Shared borrow release: same traversal but uses #decCellBorrow on writeback. + // Case: current-frame PtrLocal (shared borrow) -> decrement cell within frame rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -649,6 +649,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] + // Case: current-frame Reference (shared borrow) -> mirror PtrLocal handling rule #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -667,6 +668,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] + // Case: ancestor-frame PtrLocal (shared borrow) -> traverse stack frame and decrement rule #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -685,6 +687,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Case: ancestor-frame Reference (shared borrow) -> mirror PtrLocal handling rule #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -703,18 +706,19 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Fallback case: unknown pointer shapes for shared borrow -> skip rule #releaseBorrowCellShared(_) => .K [owise] - // Current-frame writeback: increment the borrow cell (e.g. -1 -> 0) + // Case: current-frame writeback -> increment borrow cell in locals (e.g. -1 -> 0) rule CELL:Value ~> #applyBorrowCell(J, PROJS) => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) ... - // Fallback + // Fallback case: writeback helpers received unexpected shape -> skip rule #applyBorrowCell(_, _) => .K [owise] - // Ancestor-frame writeback: increment and write back via projection + // Case: ancestor-frame writeback -> increment cell through projection rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS) => #traverseProjection( @@ -732,17 +736,19 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Fallback + // Fallback case: ancestor writeback helper -> skip rule #applyBorrowCellStack(_, _, _) => .K [owise] - // Shared borrow writeback helpers apply #decCellBorrow instead. + // Case: current-frame shared writeback -> decrement borrow cell rule CELL:Value ~> #applyBorrowCellShared(J, PROJS) => #setLocalValue(place(local(J), PROJS), #decCellBorrow(CELL)) ... + // Fallback case: shared helper unexpected shape -> skip rule #applyBorrowCellShared(_, _) => .K [owise] + // Case: ancestor-frame shared writeback -> decrement via projection rule CELL:Value ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) => #traverseProjection( @@ -760,6 +766,7 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // Fallback case: ancestor shared helper -> skip rule #applyBorrowCellStackShared(_, _, _) => .K [owise] syntax MIRError ::= "ReachedUnreachable" From 3450bc83f3fe543b466104d0a6d505ddd7e35114 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Wed, 5 Nov 2025 23:46:49 +0800 Subject: [PATCH 43/66] feat: enhance Drop terminator documentation and clarify borrow-aware drop mechanics --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 123 ++++++++-------------- 1 file changed, 43 insertions(+), 80 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 8256a2954..27c9f8db3 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -443,25 +443,20 @@ This does not sacrifice unsoundness as we would not eliminate any assertion fail Other terminators that matter at the MIR level "Runtime" are `Drop` and `Unreachable`. Drops are elaborated to Noops but still define the continuing control flow. Unreachable terminators lead to a program error. -```k - // Drop/borrow-release machinery for RefMut - // - // We model dropping RefMut as releasing the interior-mutability - // borrow it holds. The flow is: - // - Detect RefMut via type info (#isRefMutTy over #lookupMaybeTy). - // - Extract the pointer to the RefCell "borrow cell" from field - // index 1 of the RefMut aggregate and normalize pointer shapes. - // - Read the cell and write back #incCellBorrow(cell). With our - // convention, a unique (mutable) borrow stores -1; adding 1 - // yields 0, which corresponds to "no outstanding borrow". - // - // Notes: - // - Borrow cell is modeled as a 64-bit signed integer Value - // (see rt/data.md #incCellBorrow). - // - We do not assert the current flag equals -1; repeated drop - // would not trap in this model. - // - #isRefMutTy relies on string matching "RefMut<" (defined below). +#### Drop Terminator + +The `Drop` terminator traverses the target place, materialises its value and type information, and then resumes execution at the successor block once the type-directed drop handler has run. + +#### Borrow-Aware Drops + +Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping `RefMut` releases the unique borrow by incrementing the cell, while dropping `Ref` decrements the shared borrow count. The helper rules below normalise pointer shapes and apply those updates across the stack. +- Detect `RefMut` / `Ref` via `#isRefMutTy` and `#isRefTy`, which presently match the canonical names that contain `"RefMut<"` or `"Ref<"`. +- Extract projection data so that borrow cells can be reached regardless of pointer shape or stack depth. +- Update the borrow cell using `#incCellBorrow` for mutable borrows and `#decCellBorrow` for shared borrows; the cell is represented as a signed 64-bit integer (`rt/data.md`). +- The model does not assert that the borrow cell currently equals `-1`; repeated drops therefore leave the configuration unchanged. + +```k rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) => @@ -477,42 +472,11 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid local index checked - // Helpers enter here after materializing the value and type information. syntax KItem ::= #applyDrop(MaybeTy) - | #dropValue(Value, MaybeTy) - | #releaseBorrowRefMut(Value) - | #releaseBorrowRefShared(Value) - | #releaseBorrowCell(Value) - | #releaseBorrowCellShared(Value) - | #applyBorrowCell(Int, ProjectionElems) - | #applyBorrowCellShared(Int, ProjectionElems) - | #applyBorrowCellStack(Int, Int, ProjectionElems) - | #applyBorrowCellStackShared(Int, Int, ProjectionElems) - - syntax ProjectionElems ::= #withPointerOffset(ProjectionElems, Int, MetadataSize) [function, total] - rule #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE) - => appendP(PROJS, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))) - requires PTR_OFFSET =/=Int 0 - rule #withPointerOffset(PROJS, _PTR_OFFSET, _ORIGIN_SIZE) => PROJS [owise] - - // After reading the place value, delegate to type-directed drop rule VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... - // Identify Ref/RefMut via string matching; drop currently only needs these helpers. - syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] - - rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) - => findString(NAME, "RefMut<", 0) =/=Int -1 - rule #isRefMutTy(_) => false [owise] - - syntax Bool ::= #isRefTy ( TypeInfo ) [function, total] + syntax KItem ::= #dropValue(Value, MaybeTy) - rule #isRefTy(typeInfoStructType(NAME:String, _, _, _)) - => findString(NAME, "Ref<", 0) =/=Int -1 - andBool findString(NAME, "RefMut<", 0) ==Int -1 - rule #isRefTy(_) => false [owise] - - // Case: RefMut -> field #1 holds the borrow cell pointer rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefMut(getValue(ARGS, 1)) ... @@ -520,7 +484,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefMutTy(#lookupMaybeTy(MTY)) andBool 1 -> field #1 stores the shared borrow token pointing to the borrow cell rule #dropValue(Aggregate(_, ARGS), MTY) => #releaseBorrowRefShared(getValue(ARGS, 1)) ... @@ -528,30 +491,42 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre requires #isRefTy(#lookupMaybeTy(MTY)) andBool 1 no special drop behavior rule #dropValue(_:Value, MTY) => .K requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) andBool notBool #isRefTy(#lookupMaybeTy(MTY)) - // Case: RefMut wrapper contains Reference/PtrLocal -> forward to release + syntax Bool ::= #isRefMutTy ( TypeInfo ) [function, total] + rule #isRefMutTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "RefMut<", 0) =/=Int -1 + rule #isRefMutTy(_) => false [owise] + + syntax Bool ::= #isRefTy ( TypeInfo ) [function, total] + rule #isRefTy(typeInfoStructType(NAME:String, _, _, _)) + => findString(NAME, "Ref<", 0) =/=Int -1 + andBool findString(NAME, "RefMut<", 0) ==Int -1 + rule #isRefTy(_) => false [owise] + + syntax KItem ::= #releaseBorrowRefMut(Value) rule #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) => #releaseBorrowCell(PTR) ... - - // Fallback case: unknown RefMut shapes -> skip rule #releaseBorrowRefMut(_) => .K [owise] - // Case: Ref aggregate -> release shared borrow by decrementing the cell + syntax KItem ::= #releaseBorrowRefShared(Value) rule #releaseBorrowRefShared(Aggregate(_, ListItem(PTR) _)) => #releaseBorrowCellShared(PTR) ... - - // Fallback case: unknown Ref shapes -> skip rule #releaseBorrowRefShared(_) => .K [owise] - // Case: current-frame PtrLocal (OFFSET = 0) -> read cell and release in place + syntax ProjectionElems ::= #withPointerOffset(ProjectionElems, Int, MetadataSize) [function, total] + rule #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE) + => appendP(PROJS, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))) + requires PTR_OFFSET =/=Int 0 + rule #withPointerOffset(PROJS, _PTR_OFFSET, _ORIGIN_SIZE) => PROJS [owise] + + syntax KItem ::= #releaseBorrowCell(Value) rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -570,7 +545,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] // valid pointer target on current stack frame - // Case: current-frame Reference variant -> mirror PtrLocal handling rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -589,7 +563,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - // Case: ancestor-frame PtrLocal (OFFSET > 0) -> traverse stack frame and release rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -608,7 +581,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Case: ancestor-frame Reference variant -> mirror PtrLocal handling rule #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -627,10 +599,9 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Fallback case: unknown pointer shapes -> skip rule #releaseBorrowCell(_) => .K [owise] - // Case: current-frame PtrLocal (shared borrow) -> decrement cell within frame + syntax KItem ::= #releaseBorrowCellShared(Value) rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -649,7 +620,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - // Case: current-frame Reference (shared borrow) -> mirror PtrLocal handling rule #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -668,7 +638,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isTypedValue(LOCALS[J]) [preserves-definedness] - // Case: ancestor-frame PtrLocal (shared borrow) -> traverse stack frame and decrement rule #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -687,7 +656,6 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Case: ancestor-frame Reference (shared borrow) -> mirror PtrLocal handling rule #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) => #traverseProjection( @@ -706,19 +674,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - // Fallback case: unknown pointer shapes for shared borrow -> skip rule #releaseBorrowCellShared(_) => .K [owise] - // Case: current-frame writeback -> increment borrow cell in locals (e.g. -1 -> 0) + syntax KItem ::= #applyBorrowCell(Int, ProjectionElems) rule CELL:Value ~> #applyBorrowCell(J, PROJS) => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) ... - - // Fallback case: writeback helpers received unexpected shape -> skip rule #applyBorrowCell(_, _) => .K [owise] - // Case: ancestor-frame writeback -> increment cell through projection + syntax KItem ::= #applyBorrowCellStack(Int, Int, ProjectionElems) rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS) => #traverseProjection( @@ -735,20 +700,16 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool OFFSET <=Int size(STACK) andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - - // Fallback case: ancestor writeback helper -> skip rule #applyBorrowCellStack(_, _, _) => .K [owise] - // Case: current-frame shared writeback -> decrement borrow cell + syntax KItem ::= #applyBorrowCellShared(Int, ProjectionElems) rule CELL:Value ~> #applyBorrowCellShared(J, PROJS) => #setLocalValue(place(local(J), PROJS), #decCellBorrow(CELL)) ... - - // Fallback case: shared helper unexpected shape -> skip rule #applyBorrowCellShared(_, _) => .K [owise] - // Case: ancestor-frame shared writeback -> decrement via projection + syntax KItem ::= #applyBorrowCellStackShared(Int, Int, ProjectionElems) rule CELL:Value ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) => #traverseProjection( @@ -765,10 +726,12 @@ Drops are elaborated to Noops but still define the continuing control flow. Unre andBool OFFSET <=Int size(STACK) andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - - // Fallback case: ancestor shared helper -> skip rule #applyBorrowCellStackShared(_, _, _) => .K [owise] +``` + +#### Unreachable Terminator +```k syntax MIRError ::= "ReachedUnreachable" rule [termUnreachable]: #execTerminator(terminator(terminatorKindUnreachable, _SPAN)) From 1efd5f70c8c31b34d1a1d9fd88d95f41323a6ce7 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 00:26:11 +0800 Subject: [PATCH 44/66] feat: update expected step count in crate2::main.expected test --- .../data/crate-tests/two-crate-bin/crate2::main.expected | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected b/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected index 224160f42..1b47a9edc 100644 --- a/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected +++ b/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected @@ -2,7 +2,7 @@ ┌─ 1 (root, init) │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ -│ (730 steps) +│ (745 steps) ├─ 3 (terminal) │ #EndProgram ~> .K │ From cd5706454ad054bdf82fc4f361f7fe8685c618d0 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 10:30:32 +0800 Subject: [PATCH 45/66] feat: enhance drop semantics to support general drops and improve borrow reference handling --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 222 ++++------------------ 1 file changed, 42 insertions(+), 180 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 27c9f8db3..893580f22 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -457,6 +457,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping - The model does not assert that the borrow cell currently equals `-1`; repeated drops therefore leave the configuration unchanged. ```k + // TODO: support general drops (not specifically Ref/RefMut) rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) => @@ -473,25 +474,13 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping [preserves-definedness] // valid local index checked syntax KItem ::= #applyDrop(MaybeTy) - rule VAL:Value ~> #applyDrop(MTY) => #dropValue(VAL, MTY) ... - - syntax KItem ::= #dropValue(Value, MaybeTy) - - rule #dropValue(Aggregate(_, ARGS), MTY) - => #releaseBorrowRefMut(getValue(ARGS, 1)) - ... - - requires #isRefMutTy(#lookupMaybeTy(MTY)) - andBool 1 #dropValue(Aggregate(_, ARGS), MTY) - => #releaseBorrowRefShared(getValue(ARGS, 1)) + rule Aggregate(_, ARGS) ~> #applyDrop(MTY) + => #releaseBorrowRef(getValue(ARGS, 1), #isRefMutTy(#lookupMaybeTy(MTY))) ... - requires #isRefTy(#lookupMaybeTy(MTY)) - andBool 1 .K + requires 1 _:Value ~> #applyDrop(MTY) => .K ... requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) andBool notBool #isRefTy(#lookupMaybeTy(MTY)) @@ -506,46 +495,19 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool findString(NAME, "RefMut<", 0) ==Int -1 rule #isRefTy(_) => false [owise] - syntax KItem ::= #releaseBorrowRefMut(Value) - rule #releaseBorrowRefMut(Aggregate(_, ListItem(PTR) _)) - => #releaseBorrowCell(PTR) - ... - - rule #releaseBorrowRefMut(_) => .K [owise] + // Helper to release borrow reference; Bool indicates mutability + syntax KItem ::= #releaseBorrowRef(Value, Bool) - syntax KItem ::= #releaseBorrowRefShared(Value) - rule #releaseBorrowRefShared(Aggregate(_, ListItem(PTR) _)) - => #releaseBorrowCellShared(PTR) - ... - - rule #releaseBorrowRefShared(_) => .K [owise] + rule #releaseBorrowRef(Aggregate(_, ListItem(PTR) _), IS_MUT) + => #releaseBorrowRef(PTR, IS_MUT) - syntax ProjectionElems ::= #withPointerOffset(ProjectionElems, Int, MetadataSize) [function, total] - rule #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE) - => appendP(PROJS, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))) - requires PTR_OFFSET =/=Int 0 - rule #withPointerOffset(PROJS, _PTR_OFFSET, _ORIGIN_SIZE) => PROJS [owise] + rule #releaseBorrowRef(Aggregate(_, ListItem(_HEAD) ListItem(PTR) _), IS_MUT) + => #releaseBorrowRef(PTR, IS_MUT) - syntax KItem ::= #releaseBorrowCell(Value) - rule #releaseBorrowCell(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toLocal(J), - getValue(LOCALS, J), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCell(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - LOCALS - requires 0 <=Int J - andBool J #releaseBorrowRef(PtrLocal(OFFSET, PLACE, MUT, META), IS_MUT) - rule #releaseBorrowCell(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) + rule #releaseBorrowRef(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE)), IS_MUT) => #traverseProjection( toLocal(J), @@ -554,7 +516,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCell(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) + ~> #applyBorrowCellLocal(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), IS_MUT) ... LOCALS @@ -563,25 +525,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool isTypedValue(LOCALS[J]) [preserves-definedness] - rule #releaseBorrowCell(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toStack(OFFSET, local(J)), - #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCellStack(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - STACK - requires 0 #releaseBorrowCell(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) + rule #releaseBorrowRef(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE)), IS_MUT) => #traverseProjection( toStack(OFFSET, local(J)), @@ -590,127 +534,40 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping .Contexts ) ~> #readProjection(false) - ~> #applyBorrowCellStack(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) + ~> #applyBorrowCellStack(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), IS_MUT) ... STACK requires 0 .K [owise] - - syntax KItem ::= #releaseBorrowCellShared(Value) - rule #releaseBorrowCellShared(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toLocal(J), - getValue(LOCALS, J), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCellShared(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - LOCALS - requires 0 <=Int J - andBool J #releaseBorrowCellShared(Reference(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toLocal(J), - getValue(LOCALS, J), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCellShared(J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - LOCALS - requires 0 <=Int J - andBool J #releaseBorrowCellShared(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toStack(OFFSET, local(J)), - #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCellStackShared(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - STACK - requires 0 .K [owise] - rule #releaseBorrowCellShared(Reference(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) - => - #traverseProjection( - toStack(OFFSET, local(J)), - #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE), - .Contexts - ) - ~> #readProjection(false) - ~> #applyBorrowCellStackShared(OFFSET, J, #withPointerOffset(PROJS, PTR_OFFSET, ORIGIN_SIZE)) - ... - - STACK - requires 0 appendP(PROJS, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))) + requires PTR_OFFSET =/=Int 0 + rule #withPointerOffset(PROJS, _PTR_OFFSET, _ORIGIN_SIZE) => PROJS [owise] - rule #releaseBorrowCellShared(_) => .K [owise] + syntax KItem ::= #applyBorrowCellLocal(Int, ProjectionElems, Bool) + | #applyBorrowCellStack(Int, Int, ProjectionElems, Bool) - syntax KItem ::= #applyBorrowCell(Int, ProjectionElems) - rule CELL:Value ~> #applyBorrowCell(J, PROJS) - => #setLocalValue(place(local(J), PROJS), #incCellBorrow(CELL)) - ... - - rule #applyBorrowCell(_, _) => .K [owise] - - syntax KItem ::= #applyBorrowCellStack(Int, Int, ProjectionElems) - rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS) + rule CELL:Value ~> #applyBorrowCellLocal(J, PROJS, IS_MUT) => - #traverseProjection( - toStack(OFFSET, local(J)), - #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, local(J), OFFSET), - PROJS, - .Contexts + #setLocalValue( + place(local(J), PROJS), + #if IS_MUT + #then #incCellBorrow(CELL) + #else #decCellBorrow(CELL) + #fi ) - ~> #writeProjection(#incCellBorrow(CELL)) - ... - - STACK - requires 0 .K [owise] - - syntax KItem ::= #applyBorrowCellShared(Int, ProjectionElems) - rule CELL:Value ~> #applyBorrowCellShared(J, PROJS) - => #setLocalValue(place(local(J), PROJS), #decCellBorrow(CELL)) ... - rule #applyBorrowCellShared(_, _) => .K [owise] + rule #applyBorrowCellLocal(_, _, _) => .K [owise] - syntax KItem ::= #applyBorrowCellStackShared(Int, Int, ProjectionElems) - rule CELL:Value ~> #applyBorrowCellStackShared(OFFSET, J, PROJS) + rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS, IS_MUT) => #traverseProjection( toStack(OFFSET, local(J)), @@ -718,7 +575,12 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping PROJS, .Contexts ) - ~> #writeProjection(#decCellBorrow(CELL)) + ~> #writeProjection( + #if IS_MUT + #then #incCellBorrow(CELL) + #else #decCellBorrow(CELL) + #fi + ) ... STACK @@ -726,7 +588,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool OFFSET <=Int size(STACK) andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] - rule #applyBorrowCellStackShared(_, _, _) => .K [owise] + rule #applyBorrowCellStack(_, _, _, _) => .K [owise] ``` #### Unreachable Terminator From 0a1698941078814cbb83fd3da2493c85baf4f892 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 10:51:17 +0800 Subject: [PATCH 46/66] feat: enhance borrow reference handling and clarify aggregate processing in MIR semantics --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 893580f22..6829aac3b 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -474,6 +474,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping [preserves-definedness] // valid local index checked syntax KItem ::= #applyDrop(MaybeTy) + // std::cell::Ref/RefMut aggregates carry the BorrowRef helper (independent of `T`) in slot 1; rule Aggregate(_, ARGS) ~> #applyDrop(MTY) => #releaseBorrowRef(getValue(ARGS, 1), #isRefMutTy(#lookupMaybeTy(MTY))) ... @@ -498,15 +499,15 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping // Helper to release borrow reference; Bool indicates mutability syntax KItem ::= #releaseBorrowRef(Value, Bool) + // Strip tuple/struct wrappers so the borrow cell pointer can be normalised. rule #releaseBorrowRef(Aggregate(_, ListItem(PTR) _), IS_MUT) => #releaseBorrowRef(PTR, IS_MUT) - rule #releaseBorrowRef(Aggregate(_, ListItem(_HEAD) ListItem(PTR) _), IS_MUT) - => #releaseBorrowRef(PTR, IS_MUT) - + // Turn References into PtrLocal so projection traversal can reach the borrow cell. rule #releaseBorrowRef(Reference(OFFSET, PLACE, MUT, META), IS_MUT) => #releaseBorrowRef(PtrLocal(OFFSET, PLACE, MUT, META), IS_MUT) + // Stack height 0: borrow cell lives in the current frame, adjust projections (respecting pointer metadata). rule #releaseBorrowRef(PtrLocal(0, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE)), IS_MUT) => #traverseProjection( @@ -525,6 +526,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool isTypedValue(LOCALS[J]) [preserves-definedness] + // Non-zero stack height: borrow cell resides in an ancestor frame, so traverse via `toStack`. rule #releaseBorrowRef(PtrLocal(OFFSET, place(local(J), PROJS), _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE)), IS_MUT) => #traverseProjection( @@ -543,6 +545,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool isStackFrame(STACK[OFFSET -Int 1]) [preserves-definedness] + // If the value shape does not match the std Ref/RefMut layout (e.g. custom wrappers), bail out without touching memory. rule #releaseBorrowRef(_, _) => .K [owise] syntax ProjectionElems ::= #withPointerOffset(ProjectionElems, Int, MetadataSize) [function, total] @@ -554,6 +557,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping syntax KItem ::= #applyBorrowCellLocal(Int, ProjectionElems, Bool) | #applyBorrowCellStack(Int, Int, ProjectionElems, Bool) + // Write the adjusted borrow count back into the current frame's cell. rule CELL:Value ~> #applyBorrowCellLocal(J, PROJS, IS_MUT) => #setLocalValue( @@ -567,6 +571,7 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping rule #applyBorrowCellLocal(_, _, _) => .K [owise] + // Same as above, but for borrow cells located in ancestor stack frames. rule CELL:Value ~> #applyBorrowCellStack(OFFSET, J, PROJS, IS_MUT) => #traverseProjection( From 0b07a30863369d147012d9e81f88731c7be29941 Mon Sep 17 00:00:00 2001 From: JianHong Zhao Date: Thu, 6 Nov 2025 12:56:04 +0800 Subject: [PATCH 47/66] Update kmir/src/kmir/kdist/mir-semantics/kmir.md Co-authored-by: Jost Berthold --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 6829aac3b..d2994a54a 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -473,15 +473,15 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping andBool isTypedLocal(LOCALS[I]) [preserves-definedness] // valid local index checked - syntax KItem ::= #applyDrop(MaybeTy) + syntax KItem ::= #applyDrop ( Evaluation , MaybeTy ) [strict(1)] // std::cell::Ref/RefMut aggregates carry the BorrowRef helper (independent of `T`) in slot 1; - rule Aggregate(_, ARGS) ~> #applyDrop(MTY) + rule #applyDrop(Aggregate(_, ARGS), MTY) => #releaseBorrowRef(getValue(ARGS, 1), #isRefMutTy(#lookupMaybeTy(MTY))) ... requires 1 _:Value ~> #applyDrop(MTY) => .K ... + rule #applyDrop(_:Value, MTY) => .K ... requires notBool #isRefMutTy(#lookupMaybeTy(MTY)) andBool notBool #isRefTy(#lookupMaybeTy(MTY)) From d57f4f356347aa0d0f736a8511416517a25ad4d9 Mon Sep 17 00:00:00 2001 From: JianHong Zhao Date: Thu, 6 Nov 2025 12:56:13 +0800 Subject: [PATCH 48/66] Update kmir/src/kmir/kdist/mir-semantics/kmir.md Co-authored-by: Jost Berthold --- kmir/src/kmir/kdist/mir-semantics/kmir.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index d2994a54a..f3c60d776 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -461,10 +461,10 @@ Our runtime model tracks RefCell borrow counts for smart-pointer types. Dropping rule [termDrop]: #execTerminator(terminator(terminatorKindDrop(place(local(I), PROJS), TARGET, _UNWIND), _SPAN)) => - #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) - ~> #readProjection(true) - ~> #applyDrop(getTyOf(tyOfLocal(getLocal(LOCALS, I)), PROJS)) - ~> #execBlockIdx(TARGET) + #applyDrop( + operandMove(place(local(I), PROJS)), + getTyOf(tyOfLocal(getLocal(LOCALS, I)), PROJS) + ) ~> #execBlockIdx(TARGET) ... LOCALS From 541edd4bf6c0f6926b21a458445aebb3c6534a2c Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 12:58:31 +0800 Subject: [PATCH 49/66] feat: update expected step count in crate2::test_crate1_with.expected --- .../two-crate-dylib/crate2::test_crate1_with.expected | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected b/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected index bdade977c..56ffc4c40 100644 --- a/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected +++ b/kmir/src/tests/integration/data/crate-tests/two-crate-dylib/crate2::test_crate1_with.expected @@ -2,7 +2,7 @@ ┌─ 1 (root, init) │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ -│ (217 steps) +│ (219 steps) ├─ 3 (terminal) │ #EndProgram ~> .K │ From 193bef5ce7332125d590ffc9228b953c965e6d54 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 15:38:10 +0800 Subject: [PATCH 50/66] chore: update expected output --- .../data/crate-tests/two-crate-bin/crate2::main.expected | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected b/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected index 1b47a9edc..f162c21ea 100644 --- a/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected +++ b/kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected @@ -2,7 +2,7 @@ ┌─ 1 (root, init) │ #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC │ -│ (745 steps) +│ (751 steps) ├─ 3 (terminal) │ #EndProgram ~> .K │ From 8358db0a66ebf0e645076a885eddf70ce79b943d Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 16:21:56 +0800 Subject: [PATCH 51/66] test: ensure interior mut refcell updates mint and account data --- .../data/prove-rs/interior-mut-refcell.rs | 25 ++++++++++++++----- 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs b/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs index 0771c0eca..dc6f51ddd 100644 --- a/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs +++ b/kmir/src/tests/integration/data/prove-rs/interior-mut-refcell.rs @@ -96,17 +96,30 @@ pub fn dual_account_demo(account_info: &AccountInfo, mint_info: &AccountInfo) -> let mut account_write = account_info.borrow_mut_data(); let mut mint_write = mint_info.borrow_mut_data(); - MiniTokenAccount { + let expected_account = MiniTokenAccount { owner: *b"demoacct", amount: 123, status: 1, - } - .pack_into_slice(&mut account_write); - MiniMint { + }; + let expected_mint = MiniMint { decimals: 9, supply: 500, - } - .pack_into_slice(&mut mint_write); + }; + expected_account.pack_into_slice(&mut account_write); + expected_mint.pack_into_slice(&mut mint_write); + drop(account_write); + drop(mint_write); + + let account_read_after = account_info.borrow_data(); + let mint_read_after = mint_info.borrow_data(); + assert_eq!( + MiniTokenAccount::unpack_unchecked(&account_read_after), + expected_account + ); + assert_eq!( + MiniMint::unpack_unchecked(&mint_read_after), + expected_mint + ); true } From 3b3ef6ab4bef01df7f562fe7250497f5145bedc5 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 16:55:12 +0800 Subject: [PATCH 52/66] docs(rt): Clarify zero sized type limitations --- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 7325ad8a3..3131c8779 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -70,6 +70,10 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #zeroSizedType(typeInfoTupleType(.Tys)) => true rule #zeroSizedType(typeInfoStructType(_, _, .Tys, _)) => true rule #zeroSizedType(typeInfoVoidType) => true + // FIXME: Only unit tuples, empty structs, and void are recognized here; other + // zero-sized types (e.g. single-variant enums, function or closure items, + // newtype wrappers around ZSTs) still fall through because we do not consult + // the layout metadata yet. Update once we rely on machineSize(0). rule #zeroSizedType(_) => false [owise] rule #typesCompatible(typeInfoStructType(_, _, FIELD .Tys, LAYOUT), OTHER) From 9cc3eaf1791e57f3fcda952bdf8fee23cc472720 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 20:27:17 +0800 Subject: [PATCH 53/66] moved to "jh/int-bytes-cast" --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 78 -------------------- 1 file changed, 78 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index f242be65e..2fa8ff05c 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1539,42 +1539,6 @@ The first cast is reified as a `thunk`, the second one resolves it and eliminate requires lookupTy(TY_SRC_INNER) ==K lookupTy(TY_DEST_OUTER) // cast is a round-trip andBool lookupTy(TY_DEST_INNER) ==K lookupTy(TY_SRC_OUTER) // and is well-formed (invariant) - // Casting a byte array/slice to an integer reinterprets the bytes in little-endian order. - rule #cast( - Range(ELEMS), - castKindTransmute, - _TY_SOURCE, - TY_TARGET - ) - => - #intAsType( - #littleEndianFromBytes(ELEMS), - size(ELEMS) *Int 8, - #numTypeOf(lookupTy(TY_TARGET)) - ) - ... - - requires #isIntType(lookupTy(TY_TARGET)) - andBool size(ELEMS) *Int 8 ==Int #bitWidth(#numTypeOf(lookupTy(TY_TARGET))) - andBool #areLittleEndianBytes(ELEMS) - [preserves-definedness] // ensures #numTypeOf is defined - - // Casting an integer to a `[u8; N]` array materialises its little-endian bytes. - rule #cast( - Integer(VAL, WIDTH, _SIGNEDNESS), - castKindTransmute, - _TY_SOURCE, - TY_TARGET - ) - => - Range(#littleEndianBytesFromInt(VAL, WIDTH)) - ... - - requires #isStaticU8Array(lookupTy(TY_TARGET)) - andBool WIDTH >=Int 0 - andBool WIDTH %Int 8 ==Int 0 - andBool WIDTH ==Int #staticArrayLenBits(lookupTy(TY_TARGET)) - [preserves-definedness] // ensures element type/length are well-formed ``` Another specialisation is getting the discriminant of `enum`s without fields after converting some integer data to it @@ -1594,48 +1558,6 @@ If none of the `enum` variants has any fields, the `Transmute` of a number to th // ---------------------------------------------------------------- rule #isEnumWithoutFields(typeInfoEnumType(_, _, _, FIELDSS, _)) => #noFields(FIELDSS) rule #isEnumWithoutFields(_OTHER) => false [owise] - - syntax Bool ::= #areLittleEndianBytes ( List ) [function, total] - // ------------------------------------------------------------- - rule #areLittleEndianBytes(.List) => true - rule #areLittleEndianBytes(ListItem(Integer(_, 8, false)) REST) - => #areLittleEndianBytes(REST) - rule #areLittleEndianBytes(ListItem(_OTHER) _) => false [owise] - - syntax Int ::= #littleEndianFromBytes ( List ) [function] - // ----------------------------------------------------- - rule #littleEndianFromBytes(.List) => 0 - rule #littleEndianFromBytes(ListItem(Integer(BYTE, 8, false)) REST) - => BYTE +Int 256 *Int #littleEndianFromBytes(REST) - - syntax List ::= #littleEndianBytesFromInt ( Int, Int ) [function] - | #littleEndianBytes ( Int, Int ) [function] - // ------------------------------------------------------------- - rule #littleEndianBytesFromInt(VAL, WIDTH) - => #littleEndianBytes(truncate(VAL, WIDTH, Unsigned), WIDTH /Int 8) - requires WIDTH %Int 8 ==Int 0 - andBool WIDTH >=Int 0 - - rule #littleEndianBytes(_, COUNT) - => .List - requires COUNT <=Int 0 - - rule #littleEndianBytes(VAL, COUNT) - => ListItem(Integer(VAL %Int 256, 8, false)) #littleEndianBytes(VAL /Int 256, COUNT -Int 1) - requires COUNT >Int 0 - - syntax Bool ::= #isStaticU8Array ( TypeInfo ) [function, total] - // ------------------------------------------------------------- - rule #isStaticU8Array(typeInfoArrayType(ELEM_TY, someTyConst(_))) - => lookupTy(ELEM_TY) ==K typeInfoPrimitiveType(primTypeUint(uintTyU8)) - rule #isStaticU8Array(_OTHER) => false [owise] - - syntax Int ::= #staticArrayLenBits ( TypeInfo ) [function, total] - // ------------------------------------------------------------- - rule #staticArrayLenBits(typeInfoArrayType(_, someTyConst(tyConst(KIND, _)))) - => readTyConstInt(KIND) *Int 8 - [preserves-definedness] - rule #staticArrayLenBits(_OTHER) => 0 [owise] ``` From 8a77758f29956d3e1fe46f3e46c52cf9f8bf02dd Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 20:36:03 +0800 Subject: [PATCH 54/66] move to `jh/correct-offset` --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 2fa8ff05c..6cd7f23b8 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -289,11 +289,7 @@ A `Deref` projection in the projections list changes the target of the write ope STACK => STACK[(FRAME -Int 1) <- - #updateStackLocal( - {STACK[FRAME -Int 1]}:>StackFrame, - I, - #adjustRef(#buildUpdate(NEW, CONTEXTS), 0 -Int FRAME) - ) + #updateStackLocal({STACK[FRAME -Int 1]}:>StackFrame, I, #buildUpdate(NEW, CONTEXTS)) ] requires 0 STACK => STACK[(FRAME -Int 1) <- - #updateStackLocal( - {STACK[FRAME -Int 1]}:>StackFrame, - I, - #adjustRef(#buildUpdate(Moved, CONTEXTS), 0 -Int FRAME) - ) // TODO retain Ty and Mutability from _ORIGINAL + #updateStackLocal({STACK[FRAME -Int 1]}:>StackFrame, I, #buildUpdate(Moved, CONTEXTS)) // TODO retain Ty and Mutability from _ORIGINAL ] requires 0 Date: Thu, 6 Nov 2025 20:41:19 +0800 Subject: [PATCH 55/66] moved to `jh/zero-sized` --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 7 ------- 1 file changed, 7 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 6cd7f23b8..c168f2734 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -128,13 +128,6 @@ Constant operands are simply decoded according to their type. ... requires typeInfoVoidType =/=K lookupTy(TY) - - // Fallback for zero-sized constants whose type metadata was not emitted. - rule operandConstant(constOperand(_, _, mirConst(constantKindZeroSized, TY, _))) - => Aggregate(variantIdx(0), .List) - ... - - requires typeInfoVoidType ==K lookupTy(TY) ``` ### Copying and Moving From 4f9fcd9ce328041f1587380e3e1c99bd82918a26 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 20:51:44 +0800 Subject: [PATCH 56/66] moved to `jh/interior-mut` --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 13 ------------- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 8 -------- 2 files changed, 21 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index c168f2734..e5cb80e20 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -248,19 +248,6 @@ A `Deref` projection in the projections list changes the target of the write ope rule #traverseProjection(_, VAL, .ProjectionElems, _) ~> #readProjection(false) => VAL ... rule #traverseProjection(_, VAL, .ProjectionElems, _) ~> (#readProjection(true) => #writeMoved ~> VAL) ... - // interior mutability permits projected writeback - rule #traverseProjection(toLocal(I), _ORIGINAL, .ProjectionElems, CONTEXTS) - ~> #writeProjection(NEW) - => #forceSetLocal(local(I), #buildUpdate(NEW, CONTEXTS)) - ... - - LOCALS - requires CONTEXTS =/=K .Contexts - andBool 0 <=Int I andBool I TypedLocal))) - [priority(40), preserves-definedness] - rule #traverseProjection(toLocal(I), _ORIGINAL, .ProjectionElems, CONTEXTS) ~> #writeProjection(NEW) => #setLocalValue(place(local(I), .ProjectionElems), #buildUpdate(NEW, CONTEXTS)) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 3131c8779..1c2a1dc85 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -96,14 +96,6 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #structOffsets(someLayoutShape(layoutShape(fieldsShapeArbitrary(mk(OFFSETS)), _, _, _, _))) => OFFSETS rule #structOffsets(_) => .MachineSizes [owise] - syntax Bool ::= #allowsInteriorMutation(TypeInfo) [function, total] - - rule #allowsInteriorMutation(typeInfoStructType(mirString(NAME), _, _, _)) - => findString(NAME, "UnsafeCell", 0) =/=Int -1 - rule #allowsInteriorMutation(typeInfoStructType(NAME:String, _, _, _)) - => findString(NAME, "UnsafeCell", 0) =/=Int -1 - rule #allowsInteriorMutation(_) => false [owise] - ``` ## Determining types of places with projection From 83c924cafcc3bb52069d8772def9920923b4b4c7 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Thu, 6 Nov 2025 21:10:13 +0800 Subject: [PATCH 57/66] moved to `jh/zero-sized` --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 12 ------------ kmir/src/kmir/kdist/mir-semantics/rt/types.md | 11 +---------- 2 files changed, 1 insertion(+), 22 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index e5cb80e20..6d0811f6d 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1091,18 +1091,6 @@ This eliminates any `Deref` projections from the place, and also resolves `Index // rule #projectionsFor(CtxPointerOffset(OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, projectionElemSubslice(OFFSET, ORIGIN_LENGTH, false) PROJS) rule #projectionsFor(CtxPointerOffset( _, OFFSET, ORIGIN_LENGTH) CTXS, PROJS) => #projectionsFor(CTXS, PointerOffset(OFFSET, ORIGIN_LENGTH) PROJS) - // Borrowing a zero-sized local that is still `NewLocal`: initialise it, then reuse the regular rule. - rule rvalueRef(REGION, KIND, place(local(I), PROJS)) - => #forceSetLocal(local(I), Aggregate(variantIdx(0), .List)) - ~> rvalueRef(REGION, KIND, place(local(I), PROJS)) - ... - - LOCALS - requires 0 <=Int I andBool I rvalueRef(_REGION, KIND, place(local(I), PROJS)) => #traverseProjection(toLocal(I), getValue(LOCALS, I), PROJS, .Contexts) ~> #forRef(#mutabilityOf(KIND), metadata(#metadataSize(tyOfLocal({LOCALS[I]}:>TypedLocal), PROJS), 0, noMetadataSize)) // TODO: Sus on this rule diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 1c2a1dc85..6a98e561b 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -65,16 +65,7 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #typesCompatible(SRC, OTHER) => true requires #zeroSizedType(SRC) orBool #zeroSizedType(OTHER) - syntax Bool ::= #zeroSizedType ( TypeInfo ) [function, total] - - rule #zeroSizedType(typeInfoTupleType(.Tys)) => true - rule #zeroSizedType(typeInfoStructType(_, _, .Tys, _)) => true - rule #zeroSizedType(typeInfoVoidType) => true - // FIXME: Only unit tuples, empty structs, and void are recognized here; other - // zero-sized types (e.g. single-variant enums, function or closure items, - // newtype wrappers around ZSTs) still fall through because we do not consult - // the layout metadata yet. Update once we rely on machineSize(0). - rule #zeroSizedType(_) => false [owise] + rule #typesCompatible(typeInfoStructType(_, _, FIELD .Tys, LAYOUT), OTHER) => #typesCompatible(lookupTy(FIELD), OTHER) From 54ceab5f892dd65ab0355228269c3fcc640e8df1 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 10:12:17 +0800 Subject: [PATCH 58/66] chore: make ci fail faster --- kmir/src/kmir/kast.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/kmir/src/kmir/kast.py b/kmir/src/kmir/kast.py index ed6b128f0..22b7360b7 100644 --- a/kmir/src/kmir/kast.py +++ b/kmir/src/kmir/kast.py @@ -36,8 +36,6 @@ from pyk.kast.outer import KDefinition from .smir import SMIRInfo - from .ty import TypeMetadata - from .value import MetadataSize, Value _LOGGER: Final = logging.getLogger(__name__) From 00e2df2e0b49cabaa7e4a0d42e48c273fb91601a Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 10:46:08 +0800 Subject: [PATCH 59/66] chore: moved to jh/align-transparent-place --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 64 +------------------- 1 file changed, 1 insertion(+), 63 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 6d0811f6d..3adb2c24b 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1273,77 +1273,15 @@ the `Value` sort. Conversion is especially possible for the case of _Slices_ (of dynamic length) and _Arrays_ (of static length), which have the same representation `Value::Range`. -When the cast crosses transparent wrappers (for example newtypes that just forward field `0`), the pointer's -`Place` must be realigned. `#alignTransparentPlace` rewrites the projection list until the source and target -expose the same inner value: -- if the source unwraps more than the target, append an explicit `field(0)` so the target still sees that field; -- if the target unwraps more, strip any redundant tail projections with `#popTransparentTailTo`, leaving the - canonical prefix shared by both sides. - ```k rule #cast(PtrLocal(OFFSET, PLACE, MUT, META), castKindPtrToPtr, TY_SOURCE, TY_TARGET) => - PtrLocal( - OFFSET, - #alignTransparentPlace( - PLACE, - #lookupMaybeTy(pointeeTy(lookupTy(TY_SOURCE))), - #lookupMaybeTy(pointeeTy(lookupTy(TY_TARGET))) - ), - MUT, - #convertMetadata(META, lookupTy(TY_TARGET)) - ) + PtrLocal(OFFSET, PLACE, MUT, #convertMetadata(META, lookupTy(TY_TARGET))) ... requires #typesCompatible(lookupTy(TY_SOURCE), lookupTy(TY_TARGET)) [preserves-definedness] // valid map lookups checked - syntax Place ::= #alignTransparentPlace ( Place , TypeInfo , TypeInfo ) [function, total] - syntax ProjectionElems ::= #popTransparentTailTo ( ProjectionElems , TypeInfo ) [function, total] - - rule #alignTransparentPlace(place(LOCAL, PROJS), typeInfoStructType(_, _, FIELD_TY .Tys, LAYOUT) #as SOURCE, TARGET) - => #alignTransparentPlace( - place( - LOCAL, - appendP(PROJS, projectionElemField(fieldIdx(0), FIELD_TY) .ProjectionElems) - ), - lookupTy(FIELD_TY), - TARGET - ) - requires #transparentDepth(SOURCE) >Int #transparentDepth(TARGET) - andBool #zeroFieldOffset(LAYOUT) - - rule #alignTransparentPlace( - place(LOCAL, PROJS), - SOURCE, - typeInfoStructType(_, _, FIELD_TY .Tys, LAYOUT) #as TARGET - ) - => #alignTransparentPlace( - place(LOCAL, #popTransparentTailTo(PROJS, lookupTy(FIELD_TY))), - SOURCE, - lookupTy(FIELD_TY) - ) - requires #transparentDepth(SOURCE) PLACE [owise] - - rule #popTransparentTailTo( - projectionElemField(fieldIdx(0), FIELD_TY) .ProjectionElems, - TARGET - ) - => .ProjectionElems - requires lookupTy(FIELD_TY) ==K TARGET - - rule #popTransparentTailTo( - X:ProjectionElem REST:ProjectionElems, - TARGET - ) - => X #popTransparentTailTo(REST, TARGET) - requires REST =/=K .ProjectionElems - - rule #popTransparentTailTo(PROJS, _) => PROJS [owise] syntax Metadata ::= #convertMetadata ( Metadata , TypeInfo ) [function, total] // ------------------------------------------------------------------------------------- From 55f92811a2f2ef287ec455376c3dfdb0b052b5de Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 10:49:54 +0800 Subject: [PATCH 60/66] chore: moved to jh/pointer2int --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 23 ++------------------ 1 file changed, 2 insertions(+), 21 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 3adb2c24b..aaea9ca0e 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1400,28 +1400,10 @@ What can be supported without additional layout consideration is trivial casts b rule #cast(PtrLocal(_, _, _, _) #as PTR, castKindTransmute, TY_SOURCE, TY_TARGET) => PTR ... requires lookupTy(TY_SOURCE) ==K lookupTy(TY_TARGET) - - // Transmuting a pointer to an integer discards provenance and - // reinterprets the pointer’s offset as a value of the target integer type. - // Tested by `prove-rs/interior-mut3.rs` - // TODO: check its correctness, I assume the pointer offset is the address here and we can use it to recover the PtrLocal - rule #cast( - PtrLocal(_, _, _, metadata(_, PTR_OFFSET, _)), - castKindTransmute, - _TY_SOURCE, - TY_TARGET - ) - => - #intAsType( - PTR_OFFSET, - #bitWidth(#numTypeOf(lookupTy(TY_TARGET))), - #numTypeOf(lookupTy(TY_TARGET)) - ) - ... - - requires #isIntType(lookupTy(TY_TARGET)) ``` + + Other `Transmute` casts that can be resolved are round-trip casts from type A to type B and then directly back from B to A. The first cast is reified as a `thunk`, the second one resolves it and eliminates the `thunk`: @@ -1436,7 +1418,6 @@ The first cast is reified as a `thunk`, the second one resolves it and eliminate requires lookupTy(TY_SRC_INNER) ==K lookupTy(TY_DEST_OUTER) // cast is a round-trip andBool lookupTy(TY_DEST_INNER) ==K lookupTy(TY_SRC_OUTER) // and is well-formed (invariant) - ``` Another specialisation is getting the discriminant of `enum`s without fields after converting some integer data to it From 5c6128e9d024d1525612d7c5b3e70d7e350452f3 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 10:53:48 +0800 Subject: [PATCH 61/66] chore: moved to jh/delete-doc --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index aaea9ca0e..b69350455 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -461,6 +461,17 @@ This is done without consideration of the validity of the Downcast[^downcast]. If an Aggregate contains only one element and #traverseProjection becomes stuck, you can directly access this element. +Without this rule, the test `closure_access_struct-fail.rs` demonstrates the following behavior: +- The execution gets stuck after 192 steps at `#traverseProjection ( toLocal ( 2 ) , Aggregate ( variantIdx ( 0 ) , ListItem ( ... ) ) , ... )` +- The stuck state occurs because there's a Deref projection that needs to be applied to the single element of this Aggregate, but the existing Deref rules only handle pointers and references, not Aggregates + +With this rule enabled: +- The execution progresses further to 277 steps before getting stuck +- It gets stuck at a different location: `#traverseProjection ( toLocal ( 19 ) , thunk ( #decodeConstant ( constantKindAll ... ) ) , ... )` +- The rule automatically unwraps the single-element Aggregate, allowing the field access to proceed + +This rule is essential for handling closures that access struct fields, as MIR represents certain struct accesses through single-element Aggregates that need to be unwrapped. + ```k rule #traverseProjection( DEST, From 61c8c69ae3b5c0ff6cad5bb3eb6130e99a5f6387 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 10:56:20 +0800 Subject: [PATCH 62/66] chore: remove empty lines --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index b69350455..97aa85af1 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1293,7 +1293,6 @@ which have the same representation `Value::Range`. requires #typesCompatible(lookupTy(TY_SOURCE), lookupTy(TY_TARGET)) [preserves-definedness] // valid map lookups checked - syntax Metadata ::= #convertMetadata ( Metadata , TypeInfo ) [function, total] // ------------------------------------------------------------------------------------- ``` @@ -1413,8 +1412,6 @@ What can be supported without additional layout consideration is trivial casts b requires lookupTy(TY_SOURCE) ==K lookupTy(TY_TARGET) ``` - - Other `Transmute` casts that can be resolved are round-trip casts from type A to type B and then directly back from B to A. The first cast is reified as a `thunk`, the second one resolves it and eliminates the `thunk`: From 8cc88c4fef187afbc5a45b429e536b616bb8c3c5 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 11:02:08 +0800 Subject: [PATCH 63/66] chore: move to jh/align-transparent-place --- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 6a98e561b..98e355d09 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -98,24 +98,6 @@ To make this function total, an optional `MaybeTy` is used. syntax MaybeTy ::= Ty | "TyUnknown" - syntax MaybeTy ::= #transparentFieldTy ( TypeInfo ) [function, total] - - rule #transparentFieldTy(typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) => FIELD - requires #zeroFieldOffset(LAYOUT) - rule #transparentFieldTy(_) => TyUnknown [owise] - - syntax Int ::= #transparentDepth ( TypeInfo ) [function, total] - - rule #transparentDepth(typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) - => 1 +Int #transparentDepth(lookupTy(FIELD)) - requires #zeroFieldOffset(LAYOUT) - rule #transparentDepth(_) => 0 [owise] - - syntax TypeInfo ::= #lookupMaybeTy ( MaybeTy ) [function, total] - - rule #lookupMaybeTy(TY:Ty) => lookupTy(TY) - rule #lookupMaybeTy(TyUnknown) => typeInfoVoidType - syntax MaybeTy ::= getTyOf( MaybeTy , ProjectionElems ) [function, total] // ----------------------------------------------------------- rule getTyOf(TyUnknown, _ ) => TyUnknown From 82392e7bc7aa4ef16e0d7a4158beb92ad38d2e15 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 11:05:49 +0800 Subject: [PATCH 64/66] chore: move to jh/align-transparent-place --- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 26 ------------------- 1 file changed, 26 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index 98e355d09..ff751bea5 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -61,32 +61,6 @@ Pointers to arrays/slices are compatible with pointers to the element type rule #isArrayOf(typeInfoArrayType(TY, _), TY) => true rule #isArrayOf( _ , _ ) => false [owise] - - rule #typesCompatible(SRC, OTHER) => true - requires #zeroSizedType(SRC) orBool #zeroSizedType(OTHER) - - - - rule #typesCompatible(typeInfoStructType(_, _, FIELD .Tys, LAYOUT), OTHER) - => #typesCompatible(lookupTy(FIELD), OTHER) - requires #zeroFieldOffset(LAYOUT) - - rule #typesCompatible(OTHER, typeInfoStructType(_, _, FIELD .Tys, LAYOUT)) - => #typesCompatible(OTHER, lookupTy(FIELD)) - requires #zeroFieldOffset(LAYOUT) - - syntax Bool ::= #zeroFieldOffset ( MaybeLayoutShape ) [function, total] - - rule #zeroFieldOffset(LAYOUT) - => #structOffsets(LAYOUT) ==K .MachineSizes - orBool #structOffsets(LAYOUT) ==K machineSize(mirInt(0)) .MachineSizes - orBool #structOffsets(LAYOUT) ==K machineSize(0) .MachineSizes - - syntax MachineSizes ::= #structOffsets ( MaybeLayoutShape ) [function, total] - - rule #structOffsets(someLayoutShape(layoutShape(fieldsShapeArbitrary(mk(OFFSETS)), _, _, _, _))) => OFFSETS - rule #structOffsets(_) => .MachineSizes [owise] - ``` ## Determining types of places with projection From cca14521f4258215fbd493bb03c16dba814c069a Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 11:06:05 +0800 Subject: [PATCH 65/66] chore: move to jh/align-transparent-place --- kmir/src/kmir/kdist/mir-semantics/rt/types.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/types.md b/kmir/src/kmir/kdist/mir-semantics/rt/types.md index ff751bea5..b46ce90ff 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/types.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/types.md @@ -8,8 +8,6 @@ requires "value.md" module RT-TYPES imports BOOL - imports INT - imports STRING imports MAP imports K-EQUAL From 76a081e3821ce326172698645340c073534fb4c8 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Fri, 7 Nov 2025 11:07:14 +0800 Subject: [PATCH 66/66] chore: move to jh/zero-sized-decode --- kmir/src/kmir/kdist/mir-semantics/rt/data.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index 97aa85af1..073c8873c 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -1490,9 +1490,6 @@ Zero-sized types can be decoded trivially into their respective representation. // zero-sized array rule #decodeConstant(constantKindZeroSized, _TY, typeInfoArrayType(_, _)) => Range(.List) ... - // zero-sized function item (e.g., closures without captures) - rule #decodeConstant(constantKindZeroSized, _TY, typeInfoFunType(_)) - => Aggregate(variantIdx(0), .List) ... ``` Allocated constants of reference type with a single provenance map entry are decoded as references