From 4209eb5dd45eb92af6100aecde4783aad227be67 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Sat, 28 Feb 2026 15:39:30 +0800 Subject: [PATCH 1/2] fix(printer): avoid panic on non-builtin static/vtable alloc pointers --- src/printer/mir_visitor.rs | 61 +++++++++++++++++++++++++++++++++++--- 1 file changed, 57 insertions(+), 4 deletions(-) diff --git a/src/printer/mir_visitor.rs b/src/printer/mir_visitor.rs index 943e8691..cda67897 100644 --- a/src/printer/mir_visitor.rs +++ b/src/printer/mir_visitor.rs @@ -265,10 +265,63 @@ fn collect_alloc( .insert(val, (opaque_placeholder_ty(), global_alloc.clone())); } } - GlobalAlloc::Static(_) | GlobalAlloc::VTable(_, _) => { - val_collector - .visited_allocs - .insert(val, (ty, global_alloc.clone())); + GlobalAlloc::Static(_) => { + // Keep established behavior for direct pointer/reference types. + // Recovery is only for non-builtin-deref container paths. + if kind.clone().builtin_deref(true).is_none() { + let prov_ty = get_prov_ty(ty, &offset); + debug_log_println!( + "DEBUG: GlobalAlloc::Static with non-builtin-deref type; alloc_id={:?}, ty={:?}, offset={}, kind={:?}, recovered_prov_ty={:?}", + val, + ty, + offset, + kind, + prov_ty + ); + if let Some(p_ty) = prov_ty { + val_collector + .visited_allocs + .insert(val, (p_ty, global_alloc.clone())); + } else { + // Unknown is safer than recording an incorrect outer container type. + val_collector + .visited_allocs + .insert(val, (opaque_placeholder_ty(), global_alloc.clone())); + } + } else { + val_collector + .visited_allocs + .insert(val, (ty, global_alloc.clone())); + } + } + GlobalAlloc::VTable(_, _) => { + // Same policy as static allocs: preserve direct-deref behavior, + // recover only on the fallback path. + if kind.clone().builtin_deref(true).is_none() { + let prov_ty = get_prov_ty(ty, &offset); + debug_log_println!( + "DEBUG: GlobalAlloc::VTable with non-builtin-deref type; alloc_id={:?}, ty={:?}, offset={}, kind={:?}, recovered_prov_ty={:?}", + val, + ty, + offset, + kind, + prov_ty + ); + if let Some(p_ty) = prov_ty { + val_collector + .visited_allocs + .insert(val, (p_ty, global_alloc.clone())); + } else { + // Unknown is safer than recording an incorrect outer container type. + val_collector + .visited_allocs + .insert(val, (opaque_placeholder_ty(), global_alloc.clone())); + } + } else { + val_collector + .visited_allocs + .insert(val, (ty, global_alloc.clone())); + } } GlobalAlloc::Function(_) => { if !kind.is_fn_ptr() { From f2a751ed8c817417b4410d235e444cd8dc2ee202 Mon Sep 17 00:00:00 2001 From: Stevengre Date: Mon, 2 Mar 2026 12:25:46 +0800 Subject: [PATCH 2/2] test(integration): cover static and vtable fallback behavior --- src/printer/mir_visitor.rs | 10 +- tests/integration/normalise-filter.jq | 2 + .../static-vtable-nonbuiltin-deref.rs | 9 + ...vtable-nonbuiltin-deref.smir.json.expected | 3527 +++++++++++++++++ 4 files changed, 3542 insertions(+), 6 deletions(-) create mode 100644 tests/integration/programs/static-vtable-nonbuiltin-deref.rs create mode 100644 tests/integration/programs/static-vtable-nonbuiltin-deref.smir.json.expected diff --git a/src/printer/mir_visitor.rs b/src/printer/mir_visitor.rs index cda67897..3a580f86 100644 --- a/src/printer/mir_visitor.rs +++ b/src/printer/mir_visitor.rs @@ -266,8 +266,7 @@ fn collect_alloc( } } GlobalAlloc::Static(_) => { - // Keep established behavior for direct pointer/reference types. - // Recovery is only for non-builtin-deref container paths. + // Keep builtin-deref behavior; recover only non-builtin-deref cases. if kind.clone().builtin_deref(true).is_none() { let prov_ty = get_prov_ty(ty, &offset); debug_log_println!( @@ -283,7 +282,7 @@ fn collect_alloc( .visited_allocs .insert(val, (p_ty, global_alloc.clone())); } else { - // Unknown is safer than recording an incorrect outer container type. + // Recovery failed: do not treat outer container `ty` as pointee. val_collector .visited_allocs .insert(val, (opaque_placeholder_ty(), global_alloc.clone())); @@ -295,8 +294,7 @@ fn collect_alloc( } } GlobalAlloc::VTable(_, _) => { - // Same policy as static allocs: preserve direct-deref behavior, - // recover only on the fallback path. + // Same policy as Static: keep builtin-deref, recover non-builtin-deref. if kind.clone().builtin_deref(true).is_none() { let prov_ty = get_prov_ty(ty, &offset); debug_log_println!( @@ -312,7 +310,7 @@ fn collect_alloc( .visited_allocs .insert(val, (p_ty, global_alloc.clone())); } else { - // Unknown is safer than recording an incorrect outer container type. + // Unknown is safer than wrong pointee type. val_collector .visited_allocs .insert(val, (opaque_placeholder_ty(), global_alloc.clone())); diff --git a/tests/integration/normalise-filter.jq b/tests/integration/normalise-filter.jq index 7eb1f455..7de48a05 100644 --- a/tests/integration/normalise-filter.jq +++ b/tests/integration/normalise-filter.jq @@ -29,3 +29,5 @@ ( .types | map(select(.[0].FunType) | sort) ) ] | flatten(1) ) } +# drop unstable compiler-internal ids that are unrelated to this regression +| walk(if type == "object" then del(.def_id) else . end) diff --git a/tests/integration/programs/static-vtable-nonbuiltin-deref.rs b/tests/integration/programs/static-vtable-nonbuiltin-deref.rs new file mode 100644 index 00000000..3e177922 --- /dev/null +++ b/tests/integration/programs/static-vtable-nonbuiltin-deref.rs @@ -0,0 +1,9 @@ +use std::fmt::Debug; + +static S: u8 = 7; +const OBJS: [&'static dyn Debug; 1] = [&S as &dyn Debug]; + +fn main() { + // Keep trait-object constant usage so both Static and VTable allocs are emitted. + std::hint::black_box(OBJS[0]); +} diff --git a/tests/integration/programs/static-vtable-nonbuiltin-deref.smir.json.expected b/tests/integration/programs/static-vtable-nonbuiltin-deref.smir.json.expected new file mode 100644 index 00000000..eb801b9b --- /dev/null +++ b/tests/integration/programs/static-vtable-nonbuiltin-deref.smir.json.expected @@ -0,0 +1,3527 @@ +{ + "allocs": [ + { + "global_alloc": { + "Static": 0 + } + }, + { + "global_alloc": { + "VTable": [ + 9, + { + "bound_vars": [], + "value": { + "generic_args": [] + } + } + ] + } + } + ], + "functions": [ + [ + { + "IntrinsicSym": "black_box" + } + ], + [ + { + "IntrinsicSym": "black_box" + } + ], + [ + { + "NoOpSym": "" + } + ], + [ + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h" + } + ], + [ + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h" + } + ], + [ + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h" + } + ], + [ + { + "NormalSym": "_ZN4core3fmt3num3imp51_$LT$impl$u20$core..fmt..Display$u20$for$u20$u8$GT$3fmt17h" + } + ], + [ + { + "NormalSym": "_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u8$GT$3fmt17h" + } + ], + [ + { + "NormalSym": "_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u8$GT$3fmt17h" + } + ], + [ + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h" + } + ], + [ + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h" + } + ], + [ + { + "NormalSym": "_ZN4core4hint9black_box17h" + } + ], + [ + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h" + } + ] + ], + "items": [ + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 0, + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Use": { + "Constant": { + "const_": { + "id": 16, + "kind": { + "Allocated": { + "align": 8, + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "mutability": "Not", + "provenance": { + "ptrs": [ + [ + 0, + 0 + ], + [ + 8, + 1 + ] + ] + } + } + } + }, + "span": 79, + "user_ty": null + } + } + } + ] + }, + "span": 79 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "const_": { + "id": 17, + "kind": { + "Allocated": { + "align": 8, + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + } + }, + "span": 80, + "user_ty": null + } + } + } + ] + }, + "span": 80 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "const_": { + "id": 18, + "kind": { + "Allocated": { + "align": 8, + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + } + }, + "span": 32, + "user_ty": null + } + } + } + ] + }, + "span": 78 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 78 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "index": { + "Copy": { + "local": 4, + "projection": [] + } + }, + "len": { + "Move": { + "local": 5, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 78 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 3, + "projection": [ + { + "Index": 4 + } + ] + } + } + } + ] + }, + "span": 78 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 1, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 19, + "kind": "ZeroSized" + }, + "span": 81, + "user_ty": null + } + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 82 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 83 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 84 + }, + { + "mutability": "Not", + "span": 82 + }, + { + "mutability": "Mut", + "span": 78 + }, + { + "mutability": "Mut", + "span": 79 + }, + { + "mutability": "Not", + "span": 80 + }, + { + "mutability": "Mut", + "span": 78 + }, + { + "mutability": "Mut", + "span": 78 + } + ], + "span": 85, + "spread_arg": null, + "var_debug_info": [] + }, + "id": 9, + "name": "main" + } + }, + "symbol_name": "_ZN30static_vtable_nonbuiltin_deref4main17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 1, + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 66 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 66 + }, + { + "mutability": "Not", + "span": 66 + } + ], + "span": 66, + "spread_arg": null, + "var_debug_info": [] + }, + "id": 6, + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>" + } + }, + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 1, + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 13, + "kind": "ZeroSized" + }, + "span": 34, + "user_ty": null + } + }, + "target": 1, + "unwind": "Unreachable" + } + }, + "span": 35 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 67 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 68 + }, + { + "mutability": "Not", + "span": 41 + } + ], + "span": 69, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": 1, + "composite": null, + "name": "dummy", + "source_info": { + "scope": 0, + "span": 41 + }, + "value": { + "Place": { + "local": 1, + "projection": [] + } + } + } + ] + }, + "id": 7, + "name": "std::hint::black_box::<&dyn std::fmt::Debug>" + } + }, + "symbol_name": "_ZN4core4hint9black_box17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 1, + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Constant": { + "const_": { + "id": 4, + "kind": "ZeroSized" + }, + "span": 32, + "user_ty": null + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 3, + "kind": "ZeroSized" + }, + "span": 31, + "user_ty": null + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 33 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Constant": { + "const_": { + "id": 4, + "kind": "ZeroSized" + }, + "span": 32, + "user_ty": null + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 5, + "kind": "ZeroSized" + }, + "span": 34, + "user_ty": null + } + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 35 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 36 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 37 + }, + { + "mutability": "Not", + "span": 38 + }, + { + "mutability": "Not", + "span": 39 + } + ], + "span": 42, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": 1, + "composite": null, + "name": "f", + "source_info": { + "scope": 0, + "span": 38 + }, + "value": { + "Place": { + "local": 1, + "projection": [] + } + } + }, + { + "argument_index": null, + "composite": null, + "name": "result", + "source_info": { + "scope": 1, + "span": 40 + }, + "value": { + "Place": { + "local": 0, + "projection": [] + } + } + }, + { + "argument_index": 1, + "composite": null, + "name": "dummy", + "source_info": { + "scope": 2, + "span": 41 + }, + "value": { + "Const": { + "const_": { + "id": 4, + "kind": "ZeroSized" + }, + "span": 32, + "user_ty": null + } + } + } + ] + }, + "id": 3, + "name": "std::sys::backtrace::__rust_begin_short_backtrace::" + } + }, + "symbol_name": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 1, + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "const_": { + "id": 14, + "kind": { + "Allocated": { + "align": 1, + "bytes": [ + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + } + }, + "span": 71, + "user_ty": null + } + } + } + ] + }, + "span": 71 + } + ], + "terminator": { + "kind": "Return", + "span": 70 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 72 + }, + { + "mutability": "Not", + "span": 73 + } + ], + "span": 74, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 0, + "span": 73 + }, + "value": { + "Const": { + "const_": { + "id": 4, + "kind": "ZeroSized" + }, + "span": 32, + "user_ty": null + } + } + } + ] + }, + "id": 8, + "name": "<() as std::process::Termination>::report" + } + }, + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 1, + "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": { + "args": [ + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 3, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 1, + "kind": "ZeroSized" + }, + "span": 14, + "user_ty": null + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 15 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 4 + }, + "span": 19 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + } + ], + "destination": { + "local": 2, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 2, + "kind": "ZeroSized" + }, + "span": 18, + "user_ty": null + } + }, + "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": [ + { + "mutability": "Mut", + "span": 28 + }, + { + "mutability": "Mut", + "span": 3 + }, + { + "mutability": "Mut", + "span": 16 + }, + { + "mutability": "Mut", + "span": 15 + }, + { + "mutability": "Mut", + "span": 17 + }, + { + "mutability": "Mut", + "span": 22 + }, + { + "mutability": "Mut", + "span": 23 + } + ], + "span": 3, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": null, + "composite": null, + "name": "main", + "source_info": { + "scope": 0, + "span": 9 + }, + "value": { + "Place": { + "local": 1, + "projection": [ + "Deref", + { + "Field": [ + 0, + 7 + ] + } + ] + } + } + }, + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 1, + "span": 29 + }, + "value": { + "Place": { + "local": 2, + "projection": [] + } + } + }, + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 2, + "span": 30 + }, + "value": { + "Place": { + "local": 5, + "projection": [] + } + } + } + ] + }, + "id": 2, + "name": "std::rt::lang_start::<()>::{closure#0}" + } + }, + "symbol_name": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 2, + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 65 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + } + ], + "span": 65, + "spread_arg": 2, + "var_debug_info": [] + }, + "id": 5, + "name": ">::call_once" + } + }, + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 2, + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [ + "Deref" + ] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 11, + "kind": "ZeroSized" + }, + "span": 65, + "user_ty": null + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 65 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + } + ], + "span": 65, + "spread_arg": 2, + "var_debug_info": [] + }, + "id": 5, + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once" + } + }, + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 2, + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 65 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 12, + "kind": "ZeroSized" + }, + "span": 65, + "user_ty": null + } + }, + "target": 1, + "unwind": { + "Cleanup": 3 + } + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 65 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + }, + { + "mutability": "Not", + "span": 65 + } + ], + "span": 65, + "spread_arg": 2, + "var_debug_info": [] + }, + "id": 5, + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once" + } + }, + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 2, + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 44 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 45 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 21 + ] + } + ] + } + } + } + ] + }, + "span": 45 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 4, + "projection": [] + } + }, + { + "Constant": { + "const_": { + "id": 6, + "kind": { + "Allocated": { + "align": 4, + "bytes": [ + 16, + 0, + 0, + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + } + }, + "span": 32, + "user_ty": null + } + } + ] + } + ] + }, + "span": 44 + }, + { + "kind": { + "StorageDead": 4 + }, + "span": 46 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 43 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 43 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 7, + "kind": "ZeroSized" + }, + "span": 47, + "user_ty": null + } + }, + "target": 6, + "unwind": "Continue" + } + }, + "span": 48 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 43 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 50 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 51 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 21 + ] + } + ] + } + } + } + ] + }, + "span": 51 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "const_": { + "id": 8, + "kind": { + "Allocated": { + "align": 4, + "bytes": [ + 32, + 0, + 0, + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + } + }, + "span": 32, + "user_ty": null + } + } + ] + } + ] + }, + "span": 50 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 52 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 5, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 49 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 49 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 9, + "kind": "ZeroSized" + }, + "span": 53, + "user_ty": null + } + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 54 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 49 + } + ], + "terminator": { + "kind": { + "Call": { + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 10, + "kind": "ZeroSized" + }, + "span": 55, + "user_ty": null + } + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 56 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Goto": { + "target": 6 + } + }, + "span": 57 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 58 + } + } + ], + "locals": [ + { + "mutability": "Mut", + "span": 59 + }, + { + "mutability": "Not", + "span": 60 + }, + { + "mutability": "Not", + "span": 61 + }, + { + "mutability": "Mut", + "span": 44 + }, + { + "mutability": "Mut", + "span": 45 + }, + { + "mutability": "Mut", + "span": 50 + }, + { + "mutability": "Mut", + "span": 51 + } + ], + "span": 64, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 0, + "span": 60 + }, + "value": { + "Place": { + "local": 1, + "projection": [] + } + } + }, + { + "argument_index": 2, + "composite": null, + "name": "f", + "source_info": { + "scope": 0, + "span": 61 + }, + "value": { + "Place": { + "local": 2, + "projection": [] + } + } + }, + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 1, + "span": 62 + }, + "value": { + "Place": { + "local": 2, + "projection": [] + } + } + }, + { + "argument_index": 1, + "composite": null, + "name": "self", + "source_info": { + "scope": 2, + "span": 63 + }, + "value": { + "Place": { + "local": 2, + "projection": [] + } + } + } + ] + }, + "id": 4, + "name": "core::fmt::num::::fmt" + } + }, + "symbol_name": "_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemFn": { + "body": { + "arg_count": 4, + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 1 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 2 + }, + { + "kind": { + "StorageLive": 8 + }, + "span": 3 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + { + "Closure": [ + 2, + [ + { + "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": { + "args": [ + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + }, + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 5, + "projection": [] + }, + "func": { + "Constant": { + "const_": { + "id": 0, + "kind": "ZeroSized" + }, + "span": 0, + "user_ty": null + } + }, + "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": [ + { + "mutability": "Mut", + "span": 8 + }, + { + "mutability": "Not", + "span": 9 + }, + { + "mutability": "Not", + "span": 10 + }, + { + "mutability": "Not", + "span": 11 + }, + { + "mutability": "Not", + "span": 12 + }, + { + "mutability": "Mut", + "span": 1 + }, + { + "mutability": "Mut", + "span": 2 + }, + { + "mutability": "Not", + "span": 2 + }, + { + "mutability": "Not", + "span": 3 + } + ], + "span": 13, + "spread_arg": null, + "var_debug_info": [ + { + "argument_index": 1, + "composite": null, + "name": "main", + "source_info": { + "scope": 0, + "span": 9 + }, + "value": { + "Place": { + "local": 1, + "projection": [] + } + } + }, + { + "argument_index": 2, + "composite": null, + "name": "argc", + "source_info": { + "scope": 0, + "span": 10 + }, + "value": { + "Place": { + "local": 2, + "projection": [] + } + } + }, + { + "argument_index": 3, + "composite": null, + "name": "argv", + "source_info": { + "scope": 0, + "span": 11 + }, + "value": { + "Place": { + "local": 3, + "projection": [] + } + } + }, + { + "argument_index": 4, + "composite": null, + "name": "sigpipe", + "source_info": { + "scope": 0, + "span": 12 + }, + "value": { + "Place": { + "local": 4, + "projection": [] + } + } + }, + { + "argument_index": null, + "composite": null, + "name": "v", + "source_info": { + "scope": 1, + "span": 6 + }, + "value": { + "Place": { + "local": 0, + "projection": [] + } + } + } + ] + }, + "id": 1, + "name": "std::rt::lang_start::<()>" + } + }, + "symbol_name": "_ZN3std2rt10lang_start17h" + }, + { + "details": null, + "mono_item_kind": { + "MonoItemStatic": { + "allocation": { + "align": 1, + "bytes": [ + 7 + ], + "mutability": "Not", + "provenance": { + "ptrs": [] + } + }, + "id": 0, + "name": "S" + } + }, + "symbol_name": "_ZN30static_vtable_nonbuiltin_deref1S17h" + } + ], + "types": [ + [ + { + "PrimitiveType": "Bool" + } + ], + [ + { + "PrimitiveType": "Char" + } + ], + [ + { + "PrimitiveType": { + "Int": "I32" + } + } + ], + [ + { + "PrimitiveType": { + "Int": "Isize" + } + } + ], + [ + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + { + "PrimitiveType": { + "Uint": "U8" + } + } + ], + [ + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + { + "EnumType": { + "discriminants": [ + 0, + 1, + 2, + 3 + ], + "fields": "elided", + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 3, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "valid_range": { + "end": 3, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 1 + } + } + }, + { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 2 + } + } + }, + { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 3 + } + } + } + ] + } + } + }, + "name": "core::fmt::rt::Alignment" + } + } + ], + [ + { + "EnumType": { + "discriminants": [ + 0, + 1 + ], + "fields": "elided", + "layout": { + "abi": { + "ScalarPair": [ + { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + { + "abi": { + "ScalarPair": [ + { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Single": { + "index": 1 + } + } + } + ] + } + } + }, + "name": "std::option::Option" + } + } + ], + [ + { + "EnumType": { + "discriminants": [ + 0, + 1 + ], + "fields": "elided", + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 1, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 1 + } + } + } + ] + } + } + }, + "name": "std::result::Result<(), std::fmt::Error>" + } + } + ], + [ + { + "EnumType": { + "discriminants": [ + 0, + 1 + ], + "fields": "elided", + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 0 + }, + "value": { + "Int": { + "length": "I64", + "signed": true + } + } + } + } + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "name": "std::result::Result" + } + } + ], + [ + { + "StructType": { + "fields": "elided", + "layout": { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 0 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "name": "std::fmt::Error" + } + } + ], + [ + { + "StructType": { + "fields": "elided", + "layout": { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 416 + }, + { + "num_bits": 384 + }, + { + "num_bits": 448 + }, + { + "num_bits": 0 + }, + { + "num_bits": 128 + }, + { + "num_bits": 256 + } + ] + } + }, + "size": { + "num_bits": 512 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "name": "std::fmt::Formatter<'_>" + } + } + ], + [ + { + "StructType": { + "fields": "elided", + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 255, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "name": "std::process::ExitCode" + } + } + ], + [ + { + "StructType": { + "fields": "elided", + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 255, + "start": 0 + }, + "value": { + "Int": { + "length": "I8", + "signed": false + } + } + } + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "size": { + "num_bits": 8 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "name": "std::sys::pal::unix::process::process_common::ExitCode" + } + } + ], + [ + { + "ArrayType": { + "layout": { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "fields": { + "Array": { + "count": 1, + "stride": { + "num_bits": 128 + } + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "size": { + "kind": { + "Value": [ + { + "align": 8, + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "mutability": "Mut", + "provenance": { + "ptrs": [] + } + } + ] + } + } + } + } + ], + [ + { + "TupleType": { + "layout": { + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "size": { + "num_bits": 0 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "types": "elided" + } + } + ], + [ + { + "PtrType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 0 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Mut", + "pointee_type": "elided" + } + } + ], + [ + { + "PtrType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 0 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "PtrType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 0 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Mut", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Mut", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "Scalar": { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + }, + "abi_align": 8, + "fields": "Primitive", + "size": { + "num_bits": 64 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "ScalarPair": [ + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + }, + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + ] + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Mut", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "ScalarPair": [ + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + }, + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + ] + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "RefType": { + "layout": { + "abi": { + "ScalarPair": [ + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + }, + { + "Initialized": { + "valid_range": { + "end": 18446744073709551615, + "start": 1 + }, + "value": { + "Pointer": 0 + } + } + } + ] + }, + "abi_align": 8, + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "size": { + "num_bits": 128 + }, + "variants": { + "Single": { + "index": 0 + } + } + }, + "mutability": "Not", + "pointee_type": "elided" + } + } + ], + [ + { + "FunType": "{closure@std::rt::lang_start<()>::{closure#0}}" + } + ] + ] +}