diff --git a/kmir/src/kmir/kast.py b/kmir/src/kmir/kast.py index 144b8f3fa..3e84a89ce 100644 --- a/kmir/src/kmir/kast.py +++ b/kmir/src/kmir/kast.py @@ -21,6 +21,7 @@ Local, Metadata, Place, + PtrEmulationFromMetadata, PtrLocalValue, RangeValue, RefValue, @@ -330,6 +331,8 @@ def _fresh_var(self, prefix: str) -> KVariable: def _symbolic_value(self, ty: Ty, mutable: bool) -> tuple[KInner, Iterable[KInner], KInner | None]: # returns: symbolic value of given type, related constraints, related pointer metadata + ptr_emulation_label = 'ptrEmulation(_)_RT-VALUE-SYNTAX_PtrEmulation_Metadata' + no_metadata = KApply( 'Metadata', KApply('noMetadataSize', ()), @@ -450,6 +453,7 @@ def _symbolic_value(self, ty: Ty, mutable: bool) -> tuple[KInner, Iterable[KInne ref = self.ref_offset self.ref_offset += 1 self.pointees.append(_typed_value(pointee_var, pointee_ty, mutable)) + ptr_meta = metadata if metadata is not None else no_metadata return ( KApply( 'Value::PtrLocal', @@ -457,7 +461,7 @@ def _symbolic_value(self, ty: Ty, mutable: bool) -> tuple[KInner, Iterable[KInne token(0), KApply('place', (KApply('local', (token(ref),)), KApply('ProjectionElems::empty', ()))), KApply('Mutability::Mut', ()) if mutable else KApply('Mutability::Not', ()), - metadata if metadata is not None else no_metadata, + KApply(ptr_emulation_label, (ptr_meta,)), ), ), pointee_constraints, @@ -632,6 +636,7 @@ def _random_ptr_value(self, mut: bool, type_info: PtrT | RefT) -> PtrLocalValue metadata_size = NO_SIZE metadata = Metadata(size=metadata_size, pointer_offset=0, origin_size=metadata_size) + emulation = PtrEmulationFromMetadata(metadata) ref = next(self._ref) @@ -641,7 +646,7 @@ def _random_ptr_value(self, mut: bool, type_info: PtrT | RefT) -> PtrLocalValue stack_depth=0, place=Place(local=Local(ref)), mut=mut, - metadata=metadata, + emulation=emulation, ) case RefT(): return RefValue( diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir.md b/kmir/src/kmir/kdist/mir-semantics/kmir.md index 67243238e..dc74b31aa 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir.md @@ -514,6 +514,75 @@ Execution gets stuck (no matching rule) when operands have different types or un rule #extractOperandType(_, _) => TyUnknown [owise] ``` +#### Pointer Offset (`std::intrinsics::offset`) + +The `offset` intrinsic performs pointer arithmetic, adding a signed offset to a pointer. +It requires that the resulting pointer remain within bounds of the original allocation. +This implementation delegates to the existing `binOpOffset` operation which handles bounds checking. + +```k + // Offset intrinsic: evaluate operands and apply offset operation + syntax KItem ::= #execOffsetTyped(Place, Evaluation, Evaluation, Evaluation) [seqstrict(2,3,4)] + rule #execIntrinsic(IntrinsicFunction(symbol("offset")), PTR_OP:Operand OFFSET_OP:Operand .Operands, DEST) + => #execOffsetTyped(DEST, PTR_OP, OFFSET_OP, #applyBinOp(binOpOffset, PTR_OP, OFFSET_OP, false)) + ... + + rule #execOffsetTyped(DEST, _PTR:Value, _OFFSET:Value, RESULT:Value) + => #setLocalValue(DEST, RESULT) + ... + [preserves-definedness] +``` + +#### Pointer Add (`core::ptr::const_ptr::add` / `core::ptr::mut_ptr::add`) + +The `ptr::add` intrinsic adds an unsigned count to a pointer, equivalent to `offset` with the count +converted to a signed isize. This is a safe wrapper that only accepts non-negative offsets. + +```k + // ptr::add intrinsic: convert count to signed offset and delegate to offset + syntax KItem ::= #execPtrAddTyped(Place, Evaluation, Evaluation, Evaluation) [seqstrict(2,3,4)] + + rule #execIntrinsic(IntrinsicFunction(symbol("ptr_const_ptr_add")), PTR_OP:Operand COUNT_OP:Operand .Operands, DEST) + => #execPtrAddTyped(DEST, PTR_OP, COUNT_OP, #applyBinOp(binOpOffset, PTR_OP, COUNT_OP, false)) + ... + + rule #execIntrinsic(IntrinsicFunction(symbol("ptr_mut_ptr_add")), PTR_OP:Operand COUNT_OP:Operand .Operands, DEST) + => #execPtrAddTyped(DEST, PTR_OP, COUNT_OP, #applyBinOp(binOpOffset, PTR_OP, COUNT_OP, false)) + ... + + rule #execPtrAddTyped(DEST, _PTR:Value, Integer(_COUNT, _WIDTH, false), RESULT:Value) + => #setLocalValue(DEST, RESULT) + ... + [preserves-definedness] +``` + +#### Pointer Sub (`core::ptr::const_ptr::sub` / `core::ptr::mut_ptr::sub`) + +The `ptr::sub` intrinsic subtracts an unsigned count from a pointer, equivalent to `offset` with +the negated count. This moves the pointer backwards in memory. + +```k + // ptr::sub intrinsic: negate count and delegate to offset + syntax KItem ::= #execPtrSubTyped(Place, Evaluation, Evaluation, Evaluation) [seqstrict(2,3,4)] + + rule #execIntrinsic(IntrinsicFunction(symbol("ptr_const_ptr_sub")), PTR_OP:Operand COUNT_OP:Operand .Operands, DEST) + => #execPtrSubTyped(DEST, PTR_OP, COUNT_OP, #computeSubOffset(PTR_OP, COUNT_OP)) + ... + + rule #execIntrinsic(IntrinsicFunction(symbol("ptr_mut_ptr_sub")), PTR_OP:Operand COUNT_OP:Operand .Operands, DEST) + => #execPtrSubTyped(DEST, PTR_OP, COUNT_OP, #computeSubOffset(PTR_OP, COUNT_OP)) + ... + + syntax Evaluation ::= #computeSubOffset(Evaluation, Evaluation) [seqstrict] + rule #computeSubOffset(PTR:Value, Integer(COUNT, _WIDTH, false)) + => #applyBinOp(binOpOffset, PTR, Integer(0 -Int COUNT, 64, true), false) + + rule #execPtrSubTyped(DEST, _PTR:Value, Integer(_COUNT, _WIDTH, false), RESULT:Value) + => #setLocalValue(DEST, RESULT) + ... + [preserves-definedness] +``` + ### Stopping on Program Errors The semantics has a dedicated error sort to stop execution when flawed input or undefined behaviour is detected. diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/data.md b/kmir/src/kmir/kdist/mir-semantics/rt/data.md index cd744b4a2..1dab6cc49 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/data.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/data.md @@ -721,94 +721,50 @@ An attempt to read more elements than the length of the accessed array is undefi andBool PTR_OFFSET ==Int 0 [preserves-definedness] - // Ptr, 0 < OFFSET, 0 < PTR_OFFSET, ToStack + // Ptr dereference for captured locals on outer stack frames rule #traverseProjection( _DEST, - PtrLocal(OFFSET, place(LOCAL, PLACEPROJ), _MUT, metadata(SIZE, PTR_OFFSET, ORIGIN_SIZE)), + PtrLocal(OFFSET, place(LOCAL, PLACEPROJ), _MUT, EMUL), projectionElemDeref PROJS, _CTXTS ) => #traverseProjection( - toStack(OFFSET, LOCAL), + toStack(OFFSET, LOCAL), #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, LOCAL, OFFSET), - appendP(PLACEPROJ, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))), // apply reference projections with pointer offset - .Contexts // previous contexts obsolete + #applyPtrOffset(PLACEPROJ, EMUL), + .Contexts ) - ~> #derefTruncate(SIZE, PROJS) // then truncate, then continue with remaining projections + ~> #derefTruncate(ptrMetadataSize(EMUL), PROJS) ... STACK - requires 0 #traverseProjection( - _DEST, - PtrLocal(OFFSET, place(LOCAL, PLACEPROJ), _MUT, metadata(SIZE, PTR_OFFSET, _ORIGIN_SIZE)), - projectionElemDeref PROJS, - _CTXTS - ) - => #traverseProjection( - toStack(OFFSET, LOCAL), - #localFromFrame({STACK[OFFSET -Int 1]}:>StackFrame, LOCAL, OFFSET), - PLACEPROJ, // apply reference projections - .Contexts // add pointer offset context - ) - ~> #derefTruncate(SIZE, PROJS) // then truncate, then continue with remaining projections - ... - - STACK - requires 0 #traverseProjection( - _DEST, - PtrLocal(OFFSET, place(local(I), PLACEPROJ), _MUT, metadata(SIZE, PTR_OFFSET, ORIGIN_SIZE)), - projectionElemDeref PROJS, - _CTXTS - ) - => #traverseProjection( - toLocal(I), - getValue(LOCALS, I), - appendP(PLACEPROJ, PointerOffset(PTR_OFFSET, originSize(ORIGIN_SIZE))), // apply reference projections with pointer offset - .Contexts // previous contexts obsolete - ) - ~> #derefTruncate(SIZE, PROJS) // then truncate, then continue with remaining projections - ... - - LOCALS - requires OFFSET ==Int 0 - andBool 0 <=Int I andBool I #traverseProjection( _DEST, - PtrLocal(OFFSET, place(local(I), PLACEPROJ), _MUT, metadata(SIZE, PTR_OFFSET, _ORIGIN_SIZE)), + PtrLocal(0, place(local(I), PLACEPROJ), _MUT, EMUL), projectionElemDeref PROJS, _CTXTS ) => #traverseProjection( toLocal(I), getValue(LOCALS, I), - PLACEPROJ, // apply reference projections - .Contexts // add pointer offset context + #applyPtrOffset(PLACEPROJ, EMUL), + .Contexts ) - ~> #derefTruncate(SIZE, PROJS) // then truncate, then continue with remaining projections + ~> #derefTruncate(ptrMetadataSize(EMUL), PROJS) ... LOCALS - requires OFFSET ==Int 0 - andBool 0 <=Int I andBool I ListItem(PtrLocal(OFFSET, PLACE, _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) ListItem(Integer(LENGTH, 64, false)) ~> #mkAggregate(aggregateKindRawPtr(_TY, MUT)) - => PtrLocal(OFFSET, PLACE, MUT, metadata(dynamicSize(LENGTH), PTR_OFFSET, ORIGIN_SIZE)) + rule ListItem(PtrLocal(OFFSET, PLACE, _, EMUL)) ListItem(Integer(LENGTH, 64, false)) ~> #mkAggregate(aggregateKindRawPtr(_TY, MUT)) + => PtrLocal(OFFSET, PLACE, MUT, #ptrInit(metadata(dynamicSize(LENGTH), ptrOffsetValue(EMUL), ptrOriginMetadata(EMUL)))) ... - rule ListItem(PtrLocal(OFFSET, PLACE, _, metadata(_SIZE, PTR_OFFSET, ORIGIN_SIZE))) ListItem(Aggregate(_, .List)) ~> #mkAggregate(aggregateKindRawPtr(_TY, MUT)) - => PtrLocal(OFFSET, PLACE, MUT, metadata(noMetadataSize, PTR_OFFSET, ORIGIN_SIZE)) + rule ListItem(PtrLocal(OFFSET, PLACE, _, EMUL)) ListItem(Aggregate(_, .List)) ~> #mkAggregate(aggregateKindRawPtr(_TY, MUT)) + => PtrLocal(OFFSET, PLACE, MUT, #ptrInit(metadata(noMetadataSize, ptrOffsetValue(EMUL), ptrOriginMetadata(EMUL)))) ... ``` @@ -1166,8 +1122,76 @@ The operation typically creates a pointer with empty metadata. syntax Evaluation ::= #mkPtr ( WriteTo, ProjectionElems, Mutability , Metadata ) // [function, total] // ------------------------------------------------------------------------------------------ - rule #mkPtr( toLocal(I) , PROJS, MUT, META) => PtrLocal( 0 , place(local(I), PROJS), MUT, META) ... - rule #mkPtr(toStack(STACK_OFFSET, LOCAL), PROJS, MUT, META) => PtrLocal(STACK_OFFSET, place( LOCAL , PROJS), MUT, META) ... + rule #mkPtr( toLocal(I) , PROJS, MUT, META) => PtrLocal( 0 , place(local(I), PROJS), MUT, #ptrInit(META)) ... + rule #mkPtr(toStack(STACK_OFFSET, LOCAL), PROJS, MUT, META) => PtrLocal(STACK_OFFSET, place( LOCAL , PROJS), MUT, #ptrInit(META)) ... + + syntax PtrEmulation ::= #ptrInit ( Metadata ) [function, total] + // ----------------------------------------------------------- + rule #ptrInit(metadata(SIZE, OFFSET, ORIGIN)) + => ptrEmulation(metadata(SIZE, 0, ORIGIN)) + requires OFFSET ==Int 0 + rule #ptrInit(metadata(SIZE, OFFSET, ORIGIN)) + => ptrOffset(OFFSET, ptrEmulation(metadata(SIZE, 0, ORIGIN))) + requires OFFSET =/=Int 0 + + syntax Metadata ::= ptrBaseMetadata ( PtrEmulation ) [function, total] + // --------------------------------------------------------------- + rule ptrBaseMetadata(ptrEmulation(META)) => META + rule ptrBaseMetadata(ptrOffset(_, EMUL)) => ptrBaseMetadata(EMUL) + rule ptrBaseMetadata(ptrOrigSize(SIZE)) => metadata(dynamicSize(SIZE), 0, dynamicSize(SIZE)) + rule ptrBaseMetadata(InvalidOffset(_, EMUL)) => ptrBaseMetadata(EMUL) + + syntax MetadataSize ::= metadataSizeOf ( Metadata ) [function, total] + rule metadataSizeOf(metadata(SIZE, _, _)) => SIZE + + syntax MetadataSize ::= metadataOriginOf ( Metadata ) [function, total] + rule metadataOriginOf(metadata(_, _, ORIGIN)) => ORIGIN + + syntax Bool ::= metadataWithin ( MetadataSize , MetadataSize ) [function, total] + // metadataWithin(ORIGIN, REQUIRED) + rule metadataWithin(_, noMetadataSize) => true + rule metadataWithin(noMetadataSize, _) => true + rule metadataWithin(staticSize(ORIG), staticSize(NEED)) => NEED <=Int ORIG + rule metadataWithin(staticSize(ORIG), dynamicSize(NEED)) => NEED <=Int ORIG + rule metadataWithin(dynamicSize(ORIG), staticSize(NEED)) => NEED <=Int ORIG + rule metadataWithin(dynamicSize(ORIG), dynamicSize(NEED)) => NEED <=Int ORIG + + syntax Int ::= metadataDynamicLength ( MetadataSize ) [function, total] + rule metadataDynamicLength(dynamicSize(SIZE)) => SIZE + rule metadataDynamicLength(_) => 0 [owise] + + syntax Bool ::= isDynamicMetadataSize ( MetadataSize ) [function, total] + rule isDynamicMetadataSize(dynamicSize(_)) => true + rule isDynamicMetadataSize(_) => false [owise] + + syntax MetadataSize ::= ptrMetadataSize ( PtrEmulation ) [function, total] + rule ptrMetadataSize(EMUL) => metadataSizeOf(ptrBaseMetadata(EMUL)) + + syntax MetadataSize ::= ptrOriginMetadata ( PtrEmulation ) [function, total] + rule ptrOriginMetadata(EMUL) => metadataOriginOf(ptrBaseMetadata(EMUL)) + + syntax Int ::= ptrOffsetValue ( PtrEmulation ) [function, total] + rule ptrOffsetValue(ptrEmulation(metadata(_, OFFSET, _))) => OFFSET + rule ptrOffsetValue(ptrOffset(N, EMUL)) => N +Int ptrOffsetValue(EMUL) + rule ptrOffsetValue(ptrOrigSize(_)) => 0 + rule ptrOffsetValue(InvalidOffset(_, EMUL)) => ptrOffsetValue(EMUL) + + syntax Bool ::= ptrIsInvalid ( PtrEmulation ) [function, total] + rule ptrIsInvalid(InvalidOffset(_, _)) => true + rule ptrIsInvalid(ptrOffset(_, EMUL)) => ptrIsInvalid(EMUL) + rule ptrIsInvalid(ptrEmulation(_)) => false + rule ptrIsInvalid(ptrOrigSize(_)) => false + + syntax Bool ::= ptrInOriginBounds ( Int, MetadataSize ) [function, total] + rule ptrInOriginBounds(_, noMetadataSize) => true + rule ptrInOriginBounds(TOTAL, staticSize(SIZE)) => TOTAL <=Int SIZE + rule ptrInOriginBounds(TOTAL, dynamicSize(SIZE)) => TOTAL <=Int SIZE + + syntax ProjectionElems ::= #applyPtrOffset ( ProjectionElems, PtrEmulation ) [function, total] + rule #applyPtrOffset(PROJS, EMUL) + => appendP(PROJS, PointerOffset(ptrOffsetValue(EMUL), originSize(ptrOriginMetadata(EMUL)))) + requires ptrOffsetValue(EMUL) =/=Int 0 + rule #applyPtrOffset(PROJS, _) => PROJS [owise] ``` In practice, the `AddressOf` can often be found applied to references that get dereferenced first, @@ -1195,7 +1219,7 @@ a special rule for this case is applied with higher priority. syntax Value ::= refToPtrLocal ( Value , Mutability ) [function] - rule refToPtrLocal(Reference(STACK_OFFSET, PLACE, _, META), MUT) => PtrLocal(STACK_OFFSET, PLACE, MUT, META) + rule refToPtrLocal(Reference(STACK_OFFSET, PLACE, _, META), MUT) => PtrLocal(STACK_OFFSET, PLACE, MUT, #ptrInit(META)) ``` ## Type casts @@ -1271,14 +1295,69 @@ Conversion is especially possible for the case of _Slices_ (of dynamic length) a which have the same representation `Value::Range`. ```k - rule #cast(PtrLocal(OFFSET, PLACE, MUT, META), castKindPtrToPtr, TY_SOURCE, TY_TARGET) + rule #cast(PtrLocal(OFFSET, PLACE, MUT, EMUL), castKindPtrToPtr, TY_SOURCE, TY_TARGET) => - PtrLocal(OFFSET, PLACE, MUT, #convertMetadata(META, lookupTy(TY_TARGET))) + PtrLocal(OFFSET, PLACE, MUT, #convertPtrEmul(EMUL, lookupTy(TY_TARGET))) ... requires #typesCompatible(lookupTy(TY_SOURCE), lookupTy(TY_TARGET)) [preserves-definedness] // valid map lookups checked + syntax PtrEmulation ::= #convertPtrEmul ( PtrEmulation , TypeInfo ) [function, total] + // --------------------------------------------------------------------------------- + rule #convertPtrEmul(ptrEmulation(metadata(staticSize(SIZE), 0, staticSize(SIZE))), typeInfoPtrType(ELEM_TY)) + => ptrOrigSize(SIZE) + requires #metadataSize(ELEM_TY) ==K noMetadataSize + rule #convertPtrEmul(ptrEmulation(metadata(dynamicSize(SIZE), 0, dynamicSize(SIZE))), typeInfoPtrType(ELEM_TY)) + => ptrOrigSize(SIZE) + requires #metadataSize(ELEM_TY) ==K noMetadataSize + rule #convertPtrEmul(ptrEmulation(META), typeInfoPtrType(POINTEE_TY)) + => #ptrInit(#convertMetadata(META, typeInfoPtrType(POINTEE_TY))) + requires metadataWithin(metadataOriginOf(META), #metadataSize(POINTEE_TY)) + [priority(200)] + rule #convertPtrEmul(ptrEmulation(META), typeInfoRefType(POINTEE_TY)) + => #ptrInit(#convertMetadata(META, typeInfoRefType(POINTEE_TY))) + requires metadataWithin(metadataOriginOf(META), #metadataSize(POINTEE_TY)) + [priority(200)] + rule #convertPtrEmul(ptrEmulation(META), typeInfoPtrType(POINTEE_TY)) + => InvalidOffset(0, ptrEmulation(META)) + requires notBool metadataWithin(metadataOriginOf(META), #metadataSize(POINTEE_TY)) + [priority(190)] + rule #convertPtrEmul(ptrEmulation(META), typeInfoRefType(POINTEE_TY)) + => InvalidOffset(0, ptrEmulation(META)) + requires notBool metadataWithin(metadataOriginOf(META), #metadataSize(POINTEE_TY)) + [priority(190)] + rule #convertPtrEmul(ptrEmulation(META), TYPEINFO) + => #ptrInit(#convertMetadata(META, TYPEINFO)) + rule #convertPtrEmul(ptrOffset(N, EMUL), TYPEINFO) + => ptrOffset(N, #convertPtrEmul(EMUL, TYPEINFO)) + rule #convertPtrEmul(InvalidOffset(N, EMUL), TYPEINFO) + => InvalidOffset(N, #convertPtrEmul(EMUL, TYPEINFO)) + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoPtrType(POINTEE_TY)) + => ptrOrigSize(SIZE) + requires #metadataSize(POINTEE_TY) ==K noMetadataSize + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoRefType(POINTEE_TY)) + => ptrOrigSize(SIZE) + requires #metadataSize(POINTEE_TY) ==K noMetadataSize + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoPtrType(POINTEE_TY)) + => #ptrInit(metadata(#metadataSize(POINTEE_TY), 0, dynamicSize(SIZE))) + requires #metadataSize(POINTEE_TY) =/=K noMetadataSize + andBool metadataWithin(dynamicSize(SIZE), #metadataSize(POINTEE_TY)) + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoRefType(POINTEE_TY)) + => #ptrInit(metadata(#metadataSize(POINTEE_TY), 0, dynamicSize(SIZE))) + requires #metadataSize(POINTEE_TY) =/=K noMetadataSize + andBool metadataWithin(dynamicSize(SIZE), #metadataSize(POINTEE_TY)) + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoPtrType(POINTEE_TY)) + => InvalidOffset(0, ptrOrigSize(SIZE)) + requires #metadataSize(POINTEE_TY) =/=K noMetadataSize + andBool notBool metadataWithin(dynamicSize(SIZE), #metadataSize(POINTEE_TY)) + rule #convertPtrEmul(ptrOrigSize(SIZE), typeInfoRefType(POINTEE_TY)) + => InvalidOffset(0, ptrOrigSize(SIZE)) + requires #metadataSize(POINTEE_TY) =/=K noMetadataSize + andBool notBool metadataWithin(dynamicSize(SIZE), #metadataSize(POINTEE_TY)) + rule #convertPtrEmul(ptrOrigSize(SIZE), _TYPEINFO) => ptrOrigSize(SIZE) + rule #convertPtrEmul(EMUL, _) => EMUL [owise] + syntax Metadata ::= #convertMetadata ( Metadata , TypeInfo ) [function, total] // ------------------------------------------------------------------------------------- ``` @@ -1902,7 +1981,9 @@ The unary operation `unOpPtrMetadata`, when given a reference or pointer to a sl ```k rule #applyUnOp(unOpPtrMetadata, Reference(_, _, _, metadata(dynamicSize(SIZE), _, _))) => Integer(SIZE, 64, false) ... - rule #applyUnOp(unOpPtrMetadata, PtrLocal(_, _, _, metadata(dynamicSize(SIZE), _, _))) => Integer(SIZE, 64, false) ... + rule #applyUnOp(unOpPtrMetadata, PtrLocal(_, _, _, EMUL)) + => Integer(metadataDynamicLength(ptrMetadataSize(EMUL)), 64, false) ... + requires isDynamicMetadataSize(ptrMetadataSize(EMUL)) rule #applyUnOp(unOpPtrMetadata, AllocRef( _ , _, metadata(dynamicSize(SIZE), _, _))) => Integer(SIZE, 64, false) ... // could add a rule for cases without metadata @@ -1944,48 +2025,81 @@ Raw pointer comparisons ignore mutability, but require the address and metadata #### Pointer Artithmetic -Addding an offset is currently restricted to unsigned values of an length, this may be too restrictive TODO Check. -A pointer is offset by adding the magnitude of the `Integer` provided, as along as it is within the bounds of the pointer. -It is valid to offset to the end of the pointer, however I believe it in not valid to read from there TODO: Check. -A trivial case where `binOpOffset` applies an offset of `0` is added with higher priority as it is returning the same pointer. +Pointer offsets are tracked symbolically using the `PtrEmulation` sort. Offsets do not eagerly update the +underlying metadata; instead the resulting pointer records the offset amount and validation happens at dereference +time, preserving Rust's unsafe semantics. ```k - // Trivial case when adding 0 - valid for any pointer + // Pointer Offset Implementation + // + // Tracks pointer offsets using PtrEmulation which maintains: + // - ptrOrigSize(N): Original allocation size when cast from array + // - ptrOffset(N, EMUL): Valid offset N from origin + // - InvalidOffset(N, EMUL): Out-of-bounds offset + // + // Offsets are validated lazily at dereference time rather than + // when the offset is created, matching Rust's unsafe semantics. + + // Helper function for offset calculation + syntax PtrEmulation ::= ptrEmulOffset( Int, PtrEmulation ) [function, total] + + rule ptrEmulOffset(N, ptrEmulation(metadata(SIZE, OFFSET, ORIGIN_SIZE))) + => ptrOffset(OFFSET +Int N, ptrEmulation(metadata(SIZE, 0, ORIGIN_SIZE))) + requires OFFSET +Int N >=Int 0 + andBool ptrInOriginBounds(OFFSET +Int N, ORIGIN_SIZE) + + rule ptrEmulOffset(N, ptrEmulation(metadata(SIZE, OFFSET, ORIGIN_SIZE))) + => InvalidOffset(OFFSET +Int N, ptrEmulation(metadata(SIZE, 0, ORIGIN_SIZE))) + requires (OFFSET +Int N) ptrOffset(N, EMUL) + requires 0 <=Int N andBool N <=Int SIZE + + rule ptrEmulOffset(N, ptrOrigSize(SIZE) #as EMUL) => InvalidOffset(N, EMUL) + requires SIZE ptrEmulOffset(N +Int M, ORIG) + + rule ptrEmulOffset(N, OTHER) => InvalidOffset(N, OTHER) [owise] + + // Main offset rules rule #applyBinOp( binOpOffset, - PtrLocal( STACK_DEPTH , PLACE , MUT, POINTEE_METADATA ), - Integer(VAL, _WIDTH, _SIGNED), // Trivial case when adding 0 + PtrLocal(STACK_DEPTH, PLACE, MUT, EMUL), + Integer(0, _WIDTH, _SIGNED), _CHECKED) => - PtrLocal( STACK_DEPTH , PLACE , MUT, POINTEE_METADATA ) - requires VAL ==Int 0 - [preserves-definedness, priority(40)] + PtrLocal(STACK_DEPTH, PLACE, MUT, EMUL) + [priority(40)] - // Check offset bounds against origin pointer with dynamicSize metadata rule #applyBinOp( binOpOffset, - PtrLocal( STACK_DEPTH , PLACE , MUT, metadata(CURRENT_SIZE, CURRENT_OFFSET, dynamicSize(ORIGIN_SIZE)) ), - Integer(OFFSET_VAL, _WIDTH, false), // unsigned offset + PtrLocal(STACK_DEPTH, PLACE, MUT, EMUL), + Integer(N, _WIDTH, false), _CHECKED) => - PtrLocal( STACK_DEPTH , PLACE , MUT, metadata(CURRENT_SIZE, CURRENT_OFFSET +Int OFFSET_VAL, dynamicSize(ORIGIN_SIZE)) ) - requires OFFSET_VAL >=Int 0 - andBool CURRENT_OFFSET +Int OFFSET_VAL <=Int ORIGIN_SIZE - [preserves-definedness] + PtrLocal(STACK_DEPTH, PLACE, MUT, ptrEmulOffset(N, EMUL)) + requires N >Int 0 - // Check offset bounds against origin pointer with staticSize metadata rule #applyBinOp( binOpOffset, - PtrLocal( STACK_DEPTH , PLACE , MUT, metadata(CURRENT_SIZE, CURRENT_OFFSET, staticSize(ORIGIN_SIZE)) ), - Integer(OFFSET_VAL, _WIDTH, false), // unsigned offset + PtrLocal(STACK_DEPTH, PLACE, MUT, EMUL), + Integer(N, _WIDTH, true), _CHECKED) => - PtrLocal( STACK_DEPTH , PLACE , MUT, metadata(CURRENT_SIZE, CURRENT_OFFSET +Int OFFSET_VAL, staticSize(ORIGIN_SIZE)) ) - requires OFFSET_VAL >=Int 0 - andBool CURRENT_OFFSET +Int OFFSET_VAL <=Int ORIGIN_SIZE - [preserves-definedness] + PtrLocal(STACK_DEPTH, PLACE, MUT, ptrEmulOffset(N, EMUL)) + requires N =/=Int 0 ``` ```k endmodule ``` + rule #traverseProjection( + _DEST, + PtrLocal(_, _, _, InvalidOffset(_, _)), + projectionElemDeref _, + _ + ) => stuck + ... + diff --git a/kmir/src/kmir/kdist/mir-semantics/rt/value.md b/kmir/src/kmir/kdist/mir-semantics/rt/value.md index f45ca88b7..ccba6013e 100644 --- a/kmir/src/kmir/kdist/mir-semantics/rt/value.md +++ b/kmir/src/kmir/kdist/mir-semantics/rt/value.md @@ -44,7 +44,7 @@ The special `Moved` value represents values that have been used and should not b // stack depth (initially 0), place, borrow kind, metadata (size, pointer offset, origin size) | Range( List ) [symbol(Value::Range)] // homogenous values for array/slice - | PtrLocal( Int , Place , Mutability, Metadata ) + | PtrLocal( Int , Place , Mutability, PtrEmulation ) [symbol(Value::PtrLocal)] // pointer to a local TypedValue (on the stack) // fields are the same as in Reference @@ -77,6 +77,11 @@ Other types without metadata use `noMetadataSize`. syntax MetadataSize ::= "noMetadataSize" [symbol(noMetadataSize)] | staticSize ( Int ) [symbol(staticSize)] | dynamicSize ( Int ) [symbol(dynamicSize)] + + syntax PtrEmulation ::= ptrEmulation( Metadata ) [symbol(ptrEmulation)] + | ptrOffset( Int, PtrEmulation ) [symbol(ptrOffset)] + | ptrOrigSize( Int ) [symbol(ptrOrigSize)] + | InvalidOffset( Int, PtrEmulation ) [symbol(InvalidOffset)] ``` ## Local variables diff --git a/kmir/src/kmir/value.py b/kmir/src/kmir/value.py index e1374422c..6b63e3a9d 100644 --- a/kmir/src/kmir/value.py +++ b/kmir/src/kmir/value.py @@ -106,12 +106,52 @@ def to_kast(self) -> KInner: ) +@dataclass +class PtrEmulation(ABC): + @abstractmethod + def to_kast(self) -> KInner: ... + + +@dataclass +class PtrEmulationFromMetadata(PtrEmulation): + metadata: Metadata + + def to_kast(self) -> KInner: + return KApply('ptrEmulation', self.metadata.to_kast()) + + +@dataclass +class PtrOffset(PtrEmulation): + amount: int + inner: PtrEmulation + + def to_kast(self) -> KInner: + return KApply('ptrOffset', intToken(self.amount), self.inner.to_kast()) + + +@dataclass +class PtrOrigSize(PtrEmulation): + size: int + + def to_kast(self) -> KInner: + return KApply('ptrOrigSize', intToken(self.size)) + + +@dataclass +class InvalidOffset(PtrEmulation): + amount: int + inner: PtrEmulation + + def to_kast(self) -> KInner: + return KApply('InvalidOffset', intToken(self.amount), self.inner.to_kast()) + + @dataclass class PtrLocalValue(Value): stack_depth: int place: Place mut: bool - metadata: Metadata + emulation: PtrEmulation def to_kast(self) -> KInner: return KApply( @@ -119,7 +159,7 @@ def to_kast(self) -> KInner: intToken(self.stack_depth), self.place.to_kast(), KApply('Mutability::Mut') if self.mut else KApply('Mutability::Not'), - self.metadata.to_kast(), + self.emulation.to_kast(), ) diff --git a/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs new file mode 100644 index 000000000..f9354eb14 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs @@ -0,0 +1,16 @@ +fn main() { + let arr = [1u32, 2, 3, 4, 5]; + let ptr = &arr as *const [u32; 5] as *const u32; + + // Test basic offset + let _ptr1 = unsafe { ptr.offset(2) }; + + // Test chained offsets + let ptr2 = unsafe { ptr.offset(1) }; + let _ptr3 = unsafe { ptr2.offset(1) }; + + // Test boundary + let _ptr4 = unsafe { ptr.offset(5) }; + + assert!(true); +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.smir.json b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.smir.json new file mode 100644 index 000000000..e64c772e8 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.smir.json @@ -0,0 +1,6396 @@ +{ + "name": "pointer_offset_test", + "crate_id": 9741424400047934732, + "allocs": [ + { + "alloc_id": 1, + "ty": 43, + "global_alloc": { + "Memory": { + "bytes": [ + 117, + 110, + 115, + 97, + 102, + 101, + 32, + 112, + 114, + 101, + 99, + 111, + 110, + 100, + 105, + 116, + 105, + 111, + 110, + 40, + 115, + 41, + 32, + 118, + 105, + 111, + 108, + 97, + 116, + 101, + 100, + 58, + 32, + 112, + 116, + 114, + 58, + 58, + 111, + 102, + 102, + 115, + 101, + 116, + 32, + 114, + 101, + 113, + 117, + 105, + 114, + 101, + 115, + 32, + 116, + 104, + 101, + 32, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 32, + 99, + 97, + 108, + 99, + 117, + 108, + 97, + 116, + 105, + 111, + 110, + 32, + 116, + 111, + 32, + 110, + 111, + 116, + 32, + 111, + 118, + 101, + 114, + 102, + 108, + 111, + 119 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Not" + } + } + } + ], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17hb79be9f80bbc883dE" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h4b6e99776c442543E" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h0f0946a8bcc20bd4E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h36e50e3ff540d468E" + } + ], + [ + 23, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h3c7e583de1a59c3cE" + } + ], + [ + 26, + { + "NormalSym": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset18precondition_check17h802fe7196719372eE" + } + ], + [ + 32, + { + "NormalSym": "_ZN4core9panicking14panic_nounwind17h29bb45bec7ac5ee0E" + } + ], + [ + 34, + { + "IntrinsicSym": "cold_path" + } + ], + [ + 39, + { + "NormalSym": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h481e6e362c52fcb6E" + } + ], + [ + 44, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN19pointer_offset_test4main17h45a535a7021c85f2E", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 9, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 28 + }, + [ + { + "Constant": { + "span": 138, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 16 + } + } + }, + { + "Constant": { + "span": 139, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 17 + } + } + }, + { + "Constant": { + "span": 140, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 18 + } + } + }, + { + "Constant": { + "span": 141, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 19 + } + } + }, + { + "Constant": { + "span": 142, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 20 + } + } + } + ] + ] + } + ] + }, + "span": 143 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 144 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 4, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 144 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Move": { + "local": 3, + "projection": [] + } + }, + 29 + ] + } + ] + }, + "span": 145 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 135, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 39, + "id": 14 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 136, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 15 + } + } + } + ], + "destination": { + "local": 5, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 137 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 146, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 39, + "id": 14 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 147, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 21 + } + } + } + ], + "destination": { + "local": 6, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 148 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 149, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 39, + "id": 14 + } + } + }, + "args": [ + { + "Copy": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 150, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 21 + } + } + } + ], + "destination": { + "local": 7, + "projection": [] + }, + "target": 3, + "unwind": "Continue" + } + }, + "span": 151 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 152, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 39, + "id": 14 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 153, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 22 + } + } + } + ], + "destination": { + "local": 8, + "projection": [] + }, + "target": 4, + "unwind": "Continue" + } + }, + "span": 154 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 155 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 156, + "mutability": "Mut" + }, + { + "ty": 40, + "span": 157, + "mutability": "Not" + }, + { + "ty": 29, + "span": 158, + "mutability": "Not" + }, + { + "ty": 41, + "span": 159, + "mutability": "Mut" + }, + { + "ty": 42, + "span": 144, + "mutability": "Not" + }, + { + "ty": 29, + "span": 160, + "mutability": "Not" + }, + { + "ty": 29, + "span": 161, + "mutability": "Not" + }, + { + "ty": 29, + "span": 162, + "mutability": "Not" + }, + { + "ty": 29, + "span": 163, + "mutability": "Not" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 157, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 158, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "_ptr1", + "source_info": { + "span": 160, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 5, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr2", + "source_info": { + "span": 161, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 6, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "_ptr3", + "source_info": { + "span": 162, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "_ptr4", + "source_info": { + "span": 163, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 8, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 164 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17h0093ac66767bf54eE", + "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$17h3c7e583de1a59c3cE", + "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_backtrace17hb79be9f80bbc883dE", + "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": "_ZN4core10intrinsics9cold_path17h6bf355815cfef07fE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::intrinsics::cold_path", + "id": 3, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 43 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 44, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [], + "spread_arg": null, + "span": 45 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h078467d2ee565f29E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 4, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 46, + "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": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 46, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 46, + "mutability": "Not" + }, + { + "ty": 1, + "span": 46, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 46 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h0f0946a8bcc20bd4E", + "mono_item_kind": { + "MonoItemFn": { + "name": ">::call_once", + "id": 4, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 46, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 46, + "mutability": "Not" + }, + { + "ty": 1, + "span": 46, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 46 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h36e50e3ff540d468E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 4, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 46 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 46, + "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": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 46 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 46, + "mutability": "Mut" + }, + { + "ty": 12, + "span": 46, + "mutability": "Not" + }, + { + "ty": 1, + "span": 46, + "mutability": "Not" + }, + { + "ty": 24, + "span": 46, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 46 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17hd260944b4da314a9E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", + "id": 5, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 47 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 22, + "span": 47, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 47 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h481e6e362c52fcb6E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::const_ptr::::offset", + "id": 6, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 48 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "NullaryOp": [ + "UbChecks", + 25 + ] + } + ] + }, + "span": 49 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 3 + ] + ], + "otherwise": 1 + } + } + }, + "span": 48 + } + }, + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 52 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + 27 + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "NullaryOp": [ + "SizeOf", + 28 + ] + } + ] + }, + "span": 54 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 50, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 26, + "id": 8 + } + } + }, + "args": [ + { + "Move": { + "local": 5, + "projection": [] + } + }, + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Move": { + "local": 6, + "projection": [] + } + } + ], + "destination": { + "local": 4, + "projection": [] + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 51 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 6 + }, + "span": 56 + }, + { + "kind": { + "StorageDead": 5 + }, + "span": 56 + } + ], + "terminator": { + "kind": { + "Goto": { + "target": 3 + } + }, + "span": 55 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + { + "Copy": { + "local": 2, + "projection": [] + } + } + ] + } + ] + }, + "span": 59 + } + ], + "terminator": { + "kind": "Return", + "span": 57 + } + } + ], + "locals": [ + { + "ty": 29, + "span": 60, + "mutability": "Mut" + }, + { + "ty": 29, + "span": 61, + "mutability": "Not" + }, + { + "ty": 6, + "span": 62, + "mutability": "Not" + }, + { + "ty": 25, + "span": 48, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 51, + "mutability": "Not" + }, + { + "ty": 27, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 53, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 61, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 62, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 63 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset18precondition_check17h802fe7196719372eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::const_ptr::::offset::precondition_check", + "id": 7, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 4 + }, + "span": 65 + }, + { + "kind": { + "StorageLive": 16 + }, + "span": 66 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 67 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 3, + "projection": [] + } + }, + 6 + ] + } + ] + }, + "span": 67 + }, + { + "kind": { + "StorageLive": 9 + }, + "span": 68 + }, + { + "kind": { + "StorageLive": 8 + }, + "span": 69 + }, + { + "kind": { + "StorageLive": 10 + }, + "span": 70 + }, + { + "kind": { + "StorageLive": 11 + }, + "span": 71 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + 31 + ] + } + ] + }, + "span": 71 + }, + { + "kind": { + "StorageLive": 12 + }, + "span": 72 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 6, + "projection": [] + } + }, + 31 + ] + } + ] + }, + "span": 72 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "CheckedBinaryOp": [ + "Mul", + { + "Move": { + "local": 11, + "projection": [] + } + }, + { + "Move": { + "local": 12, + "projection": [] + } + } + ] + } + ] + }, + "span": 70 + }, + { + "kind": { + "StorageDead": 12 + }, + "span": 73 + }, + { + "kind": { + "StorageDead": 11 + }, + "span": 73 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 10, + "projection": [ + { + "Field": [ + 0, + 31 + ] + } + ] + } + } + } + ] + }, + "span": 74 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 10, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 75 + }, + { + "kind": { + "StorageDead": 10 + }, + "span": 76 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 8, + "projection": [] + } + }, + 6 + ] + } + ] + }, + "span": 77 + }, + { + "kind": { + "StorageDead": 8 + }, + "span": 69 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Copy": { + "local": 9, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 5 + ] + ], + "otherwise": 3 + } + } + }, + "span": 64 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 4 + }, + "span": 79 + } + ], + "terminator": { + "kind": "Return", + "span": 78 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 80, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 32, + "id": 9 + } + } + }, + "args": [ + { + "Constant": { + "span": 81, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 93, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 0 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 33, + "id": 10 + } + } + } + ], + "destination": { + "local": 5, + "projection": [] + }, + "target": null, + "unwind": "Unreachable" + } + }, + "span": 82 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 83, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 34, + "id": 11 + } + } + }, + "args": [], + "destination": { + "local": 14, + "projection": [] + }, + "target": 4, + "unwind": "Unreachable" + } + }, + "span": 84 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 9 + }, + "span": 68 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 85 + }, + { + "kind": { + "StorageDead": 16 + }, + "span": 66 + } + ], + "terminator": { + "kind": { + "Goto": { + "target": 2 + } + }, + "span": 65 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 9 + }, + "span": 68 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 85 + }, + { + "kind": { + "StorageLive": 7 + }, + "span": 86 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Cast": [ + "Transmute", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + 30 + ] + } + ] + }, + "span": 87 + }, + { + "kind": { + "StorageLive": 19 + }, + "span": 88 + }, + { + "kind": { + "StorageLive": 23 + }, + "span": 88 + }, + { + "kind": { + "StorageLive": 15 + }, + "span": 89 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 13, + "projection": [] + } + }, + 30 + ] + } + ] + }, + "span": 89 + }, + { + "kind": { + "StorageLive": 18 + }, + "span": 90 + }, + { + "kind": { + "StorageLive": 20 + }, + "span": 91 + }, + { + "kind": { + "StorageLive": 21 + }, + "span": 92 + }, + { + "kind": { + "Assign": [ + { + "local": 21, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 7, + "projection": [] + } + }, + 35 + ] + } + ] + }, + "span": 92 + }, + { + "kind": { + "StorageLive": 22 + }, + "span": 93 + }, + { + "kind": { + "Assign": [ + { + "local": 22, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 15, + "projection": [] + } + }, + 35 + ] + } + ] + }, + "span": 93 + }, + { + "kind": { + "Assign": [ + { + "local": 20, + "projection": [] + }, + { + "CheckedBinaryOp": [ + "Add", + { + "Move": { + "local": 21, + "projection": [] + } + }, + { + "Move": { + "local": 22, + "projection": [] + } + } + ] + } + ] + }, + "span": 91 + }, + { + "kind": { + "StorageDead": 22 + }, + "span": 94 + }, + { + "kind": { + "StorageDead": 21 + }, + "span": 94 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 0, + 35 + ] + } + ] + } + } + } + ] + }, + "span": 95 + }, + { + "kind": { + "Assign": [ + { + "local": 19, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 96 + }, + { + "kind": { + "StorageDead": 20 + }, + "span": 97 + }, + { + "kind": { + "Assign": [ + { + "local": 23, + "projection": [] + }, + { + "Cast": [ + "IntToInt", + { + "Copy": { + "local": 18, + "projection": [] + } + }, + 30 + ] + } + ] + }, + "span": 98 + }, + { + "kind": { + "StorageDead": 18 + }, + "span": 90 + }, + { + "kind": { + "StorageDead": 15 + }, + "span": 99 + }, + { + "kind": { + "StorageLive": 17 + }, + "span": 100 + }, + { + "kind": { + "Assign": [ + { + "local": 17, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 13, + "projection": [] + } + }, + { + "Constant": { + "span": 101, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 12 + } + } + } + ] + } + ] + }, + "span": 100 + }, + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "BinaryOp": [ + "BitXor", + { + "Copy": { + "local": 19, + "projection": [] + } + }, + { + "Move": { + "local": 17, + "projection": [] + } + } + ] + } + ] + }, + "span": 102 + }, + { + "kind": { + "StorageDead": 17 + }, + "span": 103 + }, + { + "kind": { + "StorageDead": 23 + }, + "span": 88 + }, + { + "kind": { + "StorageDead": 19 + }, + "span": 88 + }, + { + "kind": { + "StorageDead": 7 + }, + "span": 104 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "UnaryOp": [ + "Not", + { + "Copy": { + "local": 16, + "projection": [] + } + } + ] + } + ] + }, + "span": 105 + }, + { + "kind": { + "StorageDead": 16 + }, + "span": 66 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 4, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 65 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 106, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 107, + "mutability": "Not" + }, + { + "ty": 6, + "span": 107, + "mutability": "Not" + }, + { + "ty": 30, + "span": 107, + "mutability": "Not" + }, + { + "ty": 25, + "span": 65, + "mutability": "Mut" + }, + { + "ty": 36, + "span": 82, + "mutability": "Not" + }, + { + "ty": 6, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 86, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 74, + "mutability": "Not" + }, + { + "ty": 25, + "span": 75, + "mutability": "Not" + }, + { + "ty": 37, + "span": 70, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 71, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 72, + "mutability": "Mut" + }, + { + "ty": 6, + "span": 77, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 84, + "mutability": "Not" + }, + { + "ty": 30, + "span": 89, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 102, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 100, + "mutability": "Mut" + }, + { + "ty": 35, + "span": 95, + "mutability": "Not" + }, + { + "ty": 25, + "span": 96, + "mutability": "Not" + }, + { + "ty": 38, + "span": 91, + "mutability": "Mut" + }, + { + "ty": 35, + "span": 92, + "mutability": "Mut" + }, + { + "ty": 35, + "span": 93, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 98, + "mutability": "Mut" + } + ], + "arg_count": 3, + "var_debug_info": [ + { + "name": "this", + "source_info": { + "span": 107, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 107, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "size", + "source_info": { + "span": 107, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "this", + "source_info": { + "span": 108, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 109, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "size", + "source_info": { + "span": 110, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "this", + "source_info": { + "span": 111, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 111, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "size", + "source_info": { + "span": 111, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "byte_offset", + "source_info": { + "span": 112, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 13, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "overflow", + "source_info": { + "span": 113, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "self", + "source_info": { + "span": 114, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "rhs", + "source_info": { + "span": 115, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 6, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "a", + "source_info": { + "span": 116, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 13, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "b", + "source_info": { + "span": 117, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 9, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "self", + "source_info": { + "span": 118, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "rhs", + "source_info": { + "span": 119, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 6, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "a", + "source_info": { + "span": 74, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 8, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "b", + "source_info": { + "span": 75, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 9, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "b", + "source_info": { + "span": 120, + "scope": 9 + }, + "composite": null, + "value": { + "Place": { + "local": 9, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 121, + "scope": 10 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 122, + "scope": 11 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 123, + "scope": 12 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "rhs", + "source_info": { + "span": 124, + "scope": 12 + }, + "composite": null, + "value": { + "Place": { + "local": 13, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "res", + "source_info": { + "span": 125, + "scope": 13 + }, + "composite": null, + "value": { + "Place": { + "local": 23, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "overflowed", + "source_info": { + "span": 126, + "scope": 13 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "self", + "source_info": { + "span": 127, + "scope": 14 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "rhs", + "source_info": { + "span": 128, + "scope": 14 + }, + "composite": null, + "value": { + "Place": { + "local": 15, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "a", + "source_info": { + "span": 95, + "scope": 15 + }, + "composite": null, + "value": { + "Place": { + "local": 18, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "b", + "source_info": { + "span": 96, + "scope": 15 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 129 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h4b6e99776c442543E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<() as std::process::Termination>::report", + "id": 8, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 131, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 17, + "id": 13 + } + } + } + } + ] + }, + "span": 131 + } + ], + "terminator": { + "kind": "Return", + "span": 130 + } + } + ], + "locals": [ + { + "ty": 17, + "span": 132, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 133, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 133, + "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": 134 + } + } + }, + "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": 45, + "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": 46, + "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": 23, + "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": 12, + "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": 10, + "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": "Bool" + } + ], + [ + 27, + { + "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 + } + } + } + } + ], + [ + 28, + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + 29, + { + "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 + } + } + } + } + ], + [ + 30, + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + 31, + { + "PrimitiveType": { + "Int": "I64" + } + } + ], + [ + 33, + { + "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": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 35, + { + "PrimitiveType": { + "Uint": "U64" + } + } + ], + [ + 36, + "VoidType" + ], + [ + 37, + { + "TupleType": { + "types": [ + 31, + 25 + ], + "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": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 38, + { + "TupleType": { + "types": [ + 35, + 25 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 18446744073709551615 + } + } + }, + { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 40, + { + "ArrayType": { + "elem_type": 28, + "size": { + "kind": { + "Value": [ + 30, + { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 0 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 5 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 160 + } + } + } + } + ], + [ + 41, + { + "PtrType": { + "pointee_type": 40, + "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 + } + } + } + } + ], + [ + 42, + { + "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 + } + } + } + } + ], + [ + 43, + { + "PrimitiveType": "Str" + } + ], + [ + 46, + { + "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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1482, + 28, + 1482, + 28 + ] + ], + [ + 45, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1482, + 1, + 1482, + 28 + ] + ], + [ + 46, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", + 250, + 5, + 250, + 71 + ] + ], + [ + 47, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", + 521, + 1, + 521, + 56 + ] + ], + [ + 48, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 75, + 35, + 75, + 42 + ] + ], + [ + 49, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 97, + 5, + 97, + 28 + ] + ], + [ + 50, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 76, + 17, + 76, + 35 + ] + ], + [ + 51, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 76, + 17, + 76, + 46 + ] + ], + [ + 52, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 433, + 35, + 433, + 52 + ] + ], + [ + 53, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 435, + 31, + 435, + 45 + ] + ], + [ + 54, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/mem/mod.rs", + 309, + 5, + 309, + 31 + ] + ], + [ + 55, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 75, + 13, + 77, + 14 + ] + ], + [ + 56, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 76, + 45, + 76, + 46 + ] + ], + [ + 57, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 441, + 6, + 441, + 6 + ] + ], + [ + 58, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 77, + 13, + 77, + 14 + ] + ], + [ + 59, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 440, + 18, + 440, + 49 + ] + ], + [ + 61, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 405, + 32, + 405, + 36 + ] + ], + [ + 62, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 405, + 38, + 405, + 43 + ] + ], + [ + 63, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 405, + 5, + 441, + 6 + ] + ], + [ + 64, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1540, + 8, + 1540, + 9 + ] + ], + [ + 65, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 436, + 18, + 436, + 58 + ] + ], + [ + 66, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 3535, + 9, + 3535, + 61 + ] + ], + [ + 67, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 420, + 63, + 420, + 76 + ] + ], + [ + 68, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 420, + 51, + 420, + 77 + ] + ], + [ + 69, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 751, + 31, + 751, + 51 + ] + ], + [ + 70, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 26, + 2518, + 90 + ] + ], + [ + 71, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 56, + 2518, + 72 + ] + ], + [ + 72, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 74, + 2518, + 89 + ] + ], + [ + 73, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 89, + 2518, + 90 + ] + ], + [ + 74, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 18, + 2518, + 19 + ] + ], + [ + 75, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 21, + 2518, + 22 + ] + ], + [ + 76, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2518, + 90, + 2518, + 91 + ] + ], + [ + 77, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2519, + 14, + 2519, + 23 + ] + ], + [ + 78, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 73, + 14, + 73, + 14 + ] + ], + [ + 79, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 72, + 17, + 72, + 18 + ] + ], + [ + 80, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 69, + 21, + 69, + 54 + ] + ], + [ + 81, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 70, + 25, + 70, + 79 + ] + ], + [ + 82, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 69, + 21, + 71, + 22 + ] + ], + [ + 83, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1541, + 9, + 1541, + 18 + ] + ], + [ + 84, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1541, + 9, + 1541, + 20 + ] + ], + [ + 85, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 420, + 76, + 420, + 77 + ] + ], + [ + 86, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 423, + 41, + 423, + 52 + ] + ], + [ + 87, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 169, + 18, + 169, + 51 + ] + ], + [ + 88, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 423, + 53, + 423, + 88 + ] + ], + [ + 89, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2387, + 58, + 2387, + 69 + ] + ], + [ + 90, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2387, + 42, + 2387, + 70 + ] + ], + [ + 91, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 26, + 2313, + 90 + ] + ], + [ + 92, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 56, + 2313, + 72 + ] + ], + [ + 93, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 74, + 2313, + 89 + ] + ], + [ + 94, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 89, + 2313, + 90 + ] + ], + [ + 95, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 18, + 2313, + 19 + ] + ], + [ + 96, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 21, + 2313, + 22 + ] + ], + [ + 97, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2313, + 90, + 2313, + 91 + ] + ], + [ + 98, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2314, + 14, + 2314, + 23 + ] + ], + [ + 99, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2387, + 69, + 2387, + 70 + ] + ], + [ + 100, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2388, + 32, + 2388, + 41 + ] + ], + [ + 101, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2388, + 39, + 2388, + 40 + ] + ], + [ + 102, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2388, + 19, + 2388, + 41 + ] + ], + [ + 103, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2388, + 40, + 2388, + 41 + ] + ], + [ + 104, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 423, + 87, + 423, + 88 + ] + ], + [ + 105, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 424, + 21, + 424, + 30 + ] + ], + [ + 107, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 67, + 43, + 67, + 48 + ] + ], + [ + 108, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 411, + 40, + 411, + 44 + ] + ], + [ + 109, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 411, + 57, + 411, + 62 + ] + ], + [ + 110, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 411, + 71, + 411, + 75 + ] + ], + [ + 111, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 3523, + 22, + 3523, + 26 + ] + ], + [ + 112, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 420, + 30, + 420, + 41 + ] + ], + [ + 113, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 423, + 29, + 423, + 37 + ] + ], + [ + 114, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 750, + 34, + 750, + 38 + ] + ], + [ + 115, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 750, + 40, + 750, + 43 + ] + ], + [ + 116, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 751, + 18, + 751, + 19 + ] + ], + [ + 117, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 751, + 21, + 751, + 22 + ] + ], + [ + 118, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2517, + 38, + 2517, + 42 + ] + ], + [ + 119, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/int_macros.rs", + 2517, + 44, + 2517, + 47 + ] + ], + [ + 120, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/intrinsics/mod.rs", + 1534, + 23, + 1534, + 24 + ] + ], + [ + 121, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 163, + 17, + 163, + 21 + ] + ], + [ + 122, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 62, + 26, + 62, + 30 + ] + ], + [ + 123, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2386, + 45, + 2386, + 49 + ] + ], + [ + 124, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2386, + 51, + 2386, + 54 + ] + ], + [ + 125, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2387, + 18, + 2387, + 21 + ] + ], + [ + 126, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2387, + 23, + 2387, + 33 + ] + ], + [ + 127, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2312, + 38, + 2312, + 42 + ] + ], + [ + 128, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs", + 2312, + 44, + 2312, + 47 + ] + ], + [ + 129, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ub_checks.rs", + 67, + 13, + 73, + 14 + ] + ], + [ + 130, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 131, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 133, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 134, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 135, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 6, + 30, + 6, + 36 + ] + ], + [ + 136, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 6, + 37, + 6, + 38 + ] + ], + [ + 137, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 6, + 26, + 6, + 39 + ] + ], + [ + 138, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 16, + 2, + 20 + ] + ], + [ + 139, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 22, + 2, + 23 + ] + ], + [ + 140, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 25, + 2, + 26 + ] + ], + [ + 141, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 28, + 2, + 29 + ] + ], + [ + 142, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 31, + 2, + 32 + ] + ], + [ + 143, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 15, + 2, + 33 + ] + ], + [ + 144, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 3, + 15, + 3, + 19 + ] + ], + [ + 145, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 3, + 15, + 3, + 52 + ] + ], + [ + 146, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 9, + 29, + 9, + 35 + ] + ], + [ + 147, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 9, + 36, + 9, + 37 + ] + ], + [ + 148, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 9, + 25, + 9, + 38 + ] + ], + [ + 149, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 10, + 31, + 10, + 37 + ] + ], + [ + 150, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 10, + 38, + 10, + 39 + ] + ], + [ + 151, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 10, + 26, + 10, + 40 + ] + ], + [ + 152, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 13, + 30, + 13, + 36 + ] + ], + [ + 153, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 13, + 37, + 13, + 38 + ] + ], + [ + 154, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 13, + 26, + 13, + 39 + ] + ], + [ + 155, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 16, + 2, + 16, + 2 + ] + ], + [ + 157, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 2, + 9, + 2, + 12 + ] + ], + [ + 158, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 3, + 9, + 3, + 12 + ] + ], + [ + 160, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 6, + 9, + 6, + 14 + ] + ], + [ + 161, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 9, + 9, + 9, + 13 + ] + ], + [ + 162, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 10, + 9, + 10, + 14 + ] + ], + [ + 163, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 13, + 9, + 13, + 14 + ] + ], + [ + 164, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.rs", + 1, + 1, + 16, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.state b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.state new file mode 100644 index 000000000..94a706b0b --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointer_offset_test.state @@ -0,0 +1,56 @@ + + + #applyBinOp ( binOpOffset , operandCopy ( place (... local: local ( 1 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , false ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 0 ) , projection: .ProjectionElems ) ~> .K ) ~> #execStmts ( .Statements ) ~> #execTerminator ( terminator (... kind: terminatorKindReturn , span: span ( 57 ) ) ) ~> .K + + + noReturn + + + ty ( 39 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindStorageLive ( local ( 3 ) ) , span: span ( 48 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpUbChecks , ty ( 25 ) ) ) , span: span ( 49 ) ) .Statements , terminator: terminator (... kind: terminatorKindSwitchInt (... discr: operandMove ( place (... local: local ( 3 ) , projection: .ProjectionElems ) ) , targets: switchTargets (... branches: branch ( 0 , basicBlockIdx ( 3 ) ) .Branches , otherwise: basicBlockIdx ( 1 ) ) ) , span: span ( 48 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindStorageLive ( local ( 5 ) ) , span: span ( 52 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 1 ) , projection: .ProjectionElems ) ) , ty ( 27 ) ) ) , span: span ( 52 ) ) statement (... kind: statementKindStorageLive ( local ( 6 ) ) , span: span ( 53 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpSizeOf , ty ( 28 ) ) ) , span: span ( 54 ) ) .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 50 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 26 ) , id: mirConstId ( 8 ) ) ) ) , args: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) .Operands , destination: place (... local: local ( 4 ) , projection: .ProjectionElems ) , target: someBasicBlockIdx ( basicBlockIdx ( 2 ) ) , unwind: unwindActionUnreachable ) , span: span ( 51 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindStorageDead ( local ( 6 ) ) , span: span ( 56 ) ) statement (... kind: statementKindStorageDead ( local ( 5 ) ) , span: span ( 56 ) ) .Statements , terminator: terminator (... kind: terminatorKindGoto (... target: basicBlockIdx ( 3 ) ) , span: span ( 55 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindStorageDead ( local ( 3 ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 1 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 59 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 57 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 5 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 1 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , staticSize ( 5 ) ) ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 2 , 64 , true ) , ty ( 6 ) , mutabilityNot ) ) + ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 27 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 30 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Range ( ListItem ( Integer ( 1 , 32 , false ) ) + ListItem ( Integer ( 2 , 32 , false ) ) + ListItem ( Integer ( 3 , 32 , false ) ) + ListItem ( Integer ( 4 , 32 , false ) ) + ListItem ( Integer ( 5 , 32 , false ) ) ) , ty ( 40 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , staticSize ( 5 ) ) ) ) , ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( Moved , ty ( 41 ) , mutabilityMut ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 5 ) , 0 , noMetadataSize ) ) , ty ( 42 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) ) ) + 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/pointer-cast-length-test-fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/pointer-cast-length-test-fail.state index 6e2c445d7..06cf7af31 100644 --- a/kmir/src/tests/integration/data/exec-smir/pointers/pointer-cast-length-test-fail.state +++ b/kmir/src/tests/integration/data/exec-smir/pointers/pointer-cast-length-test-fail.state @@ -49,13 +49,13 @@ ListItem ( Integer ( 42 , 8 , false ) ) ListItem ( Integer ( 42 , 8 , false ) ) ListItem ( Integer ( 42 , 8 , false ) ) ) , ty ( 40 ) , mutabilityNot ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 4 ) , 0 , noMetadataSize ) ) , ty ( 35 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( staticSize ( 4 ) , 0 , noMetadataSize ) ) ) , ty ( 35 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 29 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 26 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 41 ) , mutabilityMut ) ) ListItem ( newLocal ( ty ( 39 ) , mutabilityMut ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 4 ) , 0 , noMetadataSize ) ) , ty ( 36 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( staticSize ( 4 ) , 0 , noMetadataSize ) ) ) , ty ( 36 ) , mutabilityNot ) ) ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) ListItem ( typedValue ( Integer ( 1 , 64 , false ) , ty ( 29 ) , mutabilityNot ) ) ListItem ( typedValue ( Integer ( 4 , 64 , false ) , ty ( 29 ) , mutabilityMut ) ) @@ -67,7 +67,7 @@ ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 5 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( dynamicSize ( 4 ) , 0 , noMetadataSize ) ) , ty ( 26 ) , mutabilityMut ) ) ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 5 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 4 ) , 0 , noMetadataSize ) ) , ty ( 41 ) , mutabilityNot ) ) ListItem ( newLocal ( ty ( 42 ) , mutabilityNot ) ) - ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 5 ) , projection: .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 9 ) , 0 , noMetadataSize ) ) , ty ( 37 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 5 ) , projection: .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( staticSize ( 9 ) , 0 , noMetadataSize ) ) ) , ty ( 37 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) ListItem ( newLocal ( ty ( 29 ) , mutabilityMut ) ) ListItem ( newLocal ( ty ( 26 ) , mutabilityMut ) ) diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.smir.json new file mode 100644 index 000000000..22ea86548 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.smir.json @@ -0,0 +1,15240 @@ +{ + "name": "ptr_add", + "crate_id": 5130285451514597649, + "allocs": [ + { + "alloc_id": 0, + "ty": 9, + "global_alloc": { + "Memory": { + "bytes": [ + 20 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Not" + } + } + }, + { + "alloc_id": 1, + "ty": 9, + "global_alloc": { + "Memory": { + "bytes": [ + 40 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Not" + } + } + }, + { + "alloc_id": 2, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 10, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 3, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 15, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 4, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 20, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 5, + "ty": 32, + "global_alloc": { + "Memory": { + "bytes": [ + 44, + 1, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + } + ], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h44613294a2019531E" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h7a7386912eef6c8eE" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h50bdf93eff27faf3E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17h24c6282265e4b596E" + } + ], + [ + 26, + { + "NormalSym": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i32$GT$3fmt17hf2ab32ed9d049056E" + } + ], + [ + 29, + { + "NormalSym": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u32$GT$3fmt17ha16325633f1c54feE" + } + ], + [ + 33, + { + "NormalSym": "_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u8$GT$3fmt17h27a5398f4d8ad9d3E" + } + ], + [ + 34, + { + "NormalSym": "_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u8$GT$3fmt17hd269a011e3ca7289E" + } + ], + [ + 35, + { + "NormalSym": "_ZN4core3fmt3num3imp51_$LT$impl$u20$core..fmt..Display$u20$for$u20$u8$GT$3fmt17hcb5a8318d6a04224E" + } + ], + [ + 36, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i32$GT$3fmt17h525d1efda5babc1eE" + } + ], + [ + 37, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i32$GT$3fmt17h023afc4914ab0634E" + } + ], + [ + 38, + { + "NormalSym": "_ZN4core3fmt3num3imp52_$LT$impl$u20$core..fmt..Display$u20$for$u20$i32$GT$3fmt17h60f99ce8b93bf8c3E" + } + ], + [ + 39, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u32$GT$3fmt17hd4eb660f536230f2E" + } + ], + [ + 40, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u32$GT$3fmt17he3174859d71fe4a2E" + } + ], + [ + 41, + { + "NormalSym": "_ZN4core3fmt3num3imp52_$LT$impl$u20$core..fmt..Display$u20$for$u20$u32$GT$3fmt17h3898fcbe69051268E" + } + ], + [ + 42, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17hc1131b32865155e3E" + } + ], + [ + 44, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h21b504fa3f6e826eE" + } + ], + [ + 53, + { + "NormalSym": "_ZN4core9panicking19assert_failed_inner17h45dfcec0d802af65E" + } + ], + [ + 58, + { + "NormalSym": "_ZN7ptr_add18test_ptr_add_basic17h2d4c1c4328be83c5E" + } + ], + [ + 59, + { + "NormalSym": "_ZN7ptr_add21test_ptr_add_multiple17hedd97ab8e30aacffE" + } + ], + [ + 60, + { + "NormalSym": "_ZN7ptr_add19test_ptr_add_to_end17ha4fb2bee955d094eE" + } + ], + [ + 61, + { + "NormalSym": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h02614e07558a3cf3E" + } + ], + [ + 62, + { + "NormalSym": "_ZN4core9panicking13assert_failed17h180c9a5929a286b4E" + } + ], + [ + 67, + { + "NormalSym": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h9a7f7856ea837b5dE" + } + ], + [ + 68, + { + "NormalSym": "_ZN4core9panicking13assert_failed17h455c0b47729f0e6cE" + } + ], + [ + 71, + { + "NormalSym": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hfd18af27e2716c3eE" + } + ], + [ + 72, + { + "NormalSym": "_ZN4core9panicking13assert_failed17h605ba6251d8726efE" + } + ], + [ + 82, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN3std2rt10lang_start17hd75c1f8ebd3408bdE", + "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$17h21b504fa3f6e826eE", + "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_backtrace17h44613294a2019531E", + "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": "_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h0eb0cf81faebac8fE", + "mono_item_kind": { + "MonoItemFn": { + "name": "<&u8 as std::fmt::Debug>::fmt", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 45 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 21, + "id": 6 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 44 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 48, + "mutability": "Not" + }, + { + "ty": 24, + "span": 49, + "mutability": "Not" + }, + { + "ty": 25, + "span": 48, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 49, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 50 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h7fc2f7a93d85b7fcE", + "mono_item_kind": { + "MonoItemFn": { + "name": "<&i32 as std::fmt::Debug>::fmt", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 45 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 26, + "id": 7 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 44 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 48, + "mutability": "Not" + }, + { + "ty": 24, + "span": 49, + "mutability": "Not" + }, + { + "ty": 28, + "span": 48, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 49, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 50 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h91a78f3c681e2e4fE", + "mono_item_kind": { + "MonoItemFn": { + "name": "<&u32 as std::fmt::Debug>::fmt", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 45 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 29, + "id": 8 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 44 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 48, + "mutability": "Not" + }, + { + "ty": 24, + "span": 49, + "mutability": "Not" + }, + { + "ty": 31, + "span": 48, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 49, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 50 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17h24c6282265e4b596E", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::fmt::num::::fmt", + "id": 4, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 52 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 4, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 16, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "StorageDead": 4 + }, + "span": 54 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 51 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 33, + "id": 10 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 6, + "unwind": "Continue" + } + }, + "span": 56 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 58 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 32, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 11 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 60 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 5, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 57 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 61, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 34, + "id": 12 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 62 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 63, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 35, + "id": 13 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 64 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Goto": { + "target": 6 + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 66 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 68, + "mutability": "Not" + }, + { + "ty": 24, + "span": 69, + "mutability": "Not" + }, + { + "ty": 32, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 53, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 59, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 68, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 69, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "self", + "source_info": { + "span": 70, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 71, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 72 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i32$GT$3fmt17hf2ab32ed9d049056E", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::fmt::num::::fmt", + "id": 5, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 52 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 4, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 16, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "StorageDead": 4 + }, + "span": 54 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 51 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 36, + "id": 14 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 6, + "unwind": "Continue" + } + }, + "span": 56 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 58 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 32, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 11 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 60 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 5, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 57 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 61, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 37, + "id": 15 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 62 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 63, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 38, + "id": 16 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 64 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Goto": { + "target": 6 + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 66 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 68, + "mutability": "Not" + }, + { + "ty": 24, + "span": 69, + "mutability": "Not" + }, + { + "ty": 32, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 53, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 59, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 68, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 69, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "self", + "source_info": { + "span": 70, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 71, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 72 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u32$GT$3fmt17ha16325633f1c54feE", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::fmt::num::::fmt", + "id": 6, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 52 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 4, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 16, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "StorageDead": 4 + }, + "span": 54 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 51 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 39, + "id": 17 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 6, + "unwind": "Continue" + } + }, + "span": 56 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 58 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 32 + ] + } + ] + } + } + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 32, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 11 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 60 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 5, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 57 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 61, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 40, + "id": 18 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 62 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 63, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 41, + "id": 19 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 64 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Goto": { + "target": 6 + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 66 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 68, + "mutability": "Not" + }, + { + "ty": 24, + "span": 69, + "mutability": "Not" + }, + { + "ty": 32, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 53, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 59, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 68, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 69, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "self", + "source_info": { + "span": 70, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 71, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 72 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h271764151929b458E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 7, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 73, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 42, + "id": 20 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [ + "Deref" + ] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 43, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h50bdf93eff27faf3E", + "mono_item_kind": { + "MonoItemFn": { + "name": ">::call_once", + "id": 7, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17hc1131b32865155e3E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 7, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 73 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 73, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 44, + "id": 21 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": { + "Cleanup": 3 + } + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 12, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + }, + { + "ty": 45, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr27drop_in_place$LT$$RF$u8$GT$17h2099e5a7bc243cd3E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<&u8>", + "id": 8, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 46, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr28drop_in_place$LT$$RF$i32$GT$17h75c533764e50bd2bE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<&i32>", + "id": 8, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 47, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr28drop_in_place$LT$$RF$u32$GT$17h03a2d6a983e3fa62E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<&u32>", + "id": 8, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h2ff3ac2d64dee050E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", + "id": 8, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 43, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h02614e07558a3cf3E", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::const_ptr::::add", + "id": 9, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + { + "Copy": { + "local": 2, + "projection": [] + } + } + ] + } + ] + }, + "span": 76 + } + ], + "terminator": { + "kind": "Return", + "span": 75 + } + } + ], + "locals": [ + { + "ty": 49, + "span": 77, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 78, + "mutability": "Not" + }, + { + "ty": 50, + "span": 79, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 78, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 79, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 80 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h9a7f7856ea837b5dE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::const_ptr::::add", + "id": 9, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + { + "Copy": { + "local": 2, + "projection": [] + } + } + ] + } + ] + }, + "span": 76 + } + ], + "terminator": { + "kind": "Return", + "span": 75 + } + } + ], + "locals": [ + { + "ty": 51, + "span": 77, + "mutability": "Mut" + }, + { + "ty": 51, + "span": 78, + "mutability": "Not" + }, + { + "ty": 50, + "span": 79, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 78, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 79, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 80 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hfd18af27e2716c3eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::const_ptr::::add", + "id": 9, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 1, + "projection": [] + } + }, + { + "Copy": { + "local": 2, + "projection": [] + } + } + ] + } + ] + }, + "span": 76 + } + ], + "terminator": { + "kind": "Return", + "span": 75 + } + } + ], + "locals": [ + { + "ty": 52, + "span": 77, + "mutability": "Mut" + }, + { + "ty": 52, + "span": 78, + "mutability": "Not" + }, + { + "ty": 50, + "span": 79, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 78, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "count", + "source_info": { + "span": 79, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 80 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core9panicking13assert_failed17h180c9a5929a286b4E", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::panicking::assert_failed::", + "id": 10, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [] + } + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 6, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "StorageLive": 7 + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 3, + "projection": [] + } + ] + } + ] + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 8, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 84 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 81, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 53, + "id": 22 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 5, + "projection": [] + } + }, + { + "Move": { + "local": 7, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 82 + } + } + ], + "locals": [ + { + "ty": 55, + "span": 85, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 86, + "mutability": "Not" + }, + { + "ty": 25, + "span": 87, + "mutability": "Not" + }, + { + "ty": 25, + "span": 88, + "mutability": "Not" + }, + { + "ty": 57, + "span": 89, + "mutability": "Not" + }, + { + "ty": 54, + "span": 83, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 83, + "mutability": "Not" + }, + { + "ty": 54, + "span": 84, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 84, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "kind", + "source_info": { + "span": 86, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "left", + "source_info": { + "span": 87, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "right", + "source_info": { + "span": 88, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "args", + "source_info": { + "span": 89, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + } + ], + "spread_arg": null, + "span": 90 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core9panicking13assert_failed17h455c0b47729f0e6cE", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::panicking::assert_failed::", + "id": 10, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [] + } + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 6, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "StorageLive": 7 + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 3, + "projection": [] + } + ] + } + ] + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 8, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 84 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 81, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 53, + "id": 22 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 5, + "projection": [] + } + }, + { + "Move": { + "local": 7, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 82 + } + } + ], + "locals": [ + { + "ty": 55, + "span": 85, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 86, + "mutability": "Not" + }, + { + "ty": 28, + "span": 87, + "mutability": "Not" + }, + { + "ty": 28, + "span": 88, + "mutability": "Not" + }, + { + "ty": 57, + "span": 89, + "mutability": "Not" + }, + { + "ty": 54, + "span": 83, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 83, + "mutability": "Not" + }, + { + "ty": 54, + "span": 84, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 84, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "kind", + "source_info": { + "span": 86, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "left", + "source_info": { + "span": 87, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "right", + "source_info": { + "span": 88, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "args", + "source_info": { + "span": 89, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + } + ], + "spread_arg": null, + "span": 90 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core9panicking13assert_failed17h605ba6251d8726efE", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::panicking::assert_failed::", + "id": 10, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [] + } + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 6, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 83 + }, + { + "kind": { + "StorageLive": 7 + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 3, + "projection": [] + } + ] + } + ] + }, + "span": 84 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 8, + "projection": [] + } + }, + 54 + ] + } + ] + }, + "span": 84 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 81, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 53, + "id": 22 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 5, + "projection": [] + } + }, + { + "Move": { + "local": 7, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 82 + } + } + ], + "locals": [ + { + "ty": 55, + "span": 85, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 86, + "mutability": "Not" + }, + { + "ty": 31, + "span": 87, + "mutability": "Not" + }, + { + "ty": 31, + "span": 88, + "mutability": "Not" + }, + { + "ty": 57, + "span": 89, + "mutability": "Not" + }, + { + "ty": 54, + "span": 83, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 83, + "mutability": "Not" + }, + { + "ty": 54, + "span": 84, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 84, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "kind", + "source_info": { + "span": 86, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "left", + "source_info": { + "span": 87, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "right", + "source_info": { + "span": 88, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "args", + "source_info": { + "span": 89, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + } + ], + "spread_arg": null, + "span": 90 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h7a7386912eef6c8eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "<() as std::process::Termination>::report", + "id": 11, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 92, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 17, + "id": 23 + } + } + } + } + ] + }, + "span": 92 + } + ], + "terminator": { + "kind": "Return", + "span": 91 + } + } + ], + "locals": [ + { + "ty": 17, + "span": 93, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 94, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 94, + "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": 95 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN7ptr_add18test_ptr_add_basic17h2d4c1c4328be83c5E", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_ptr_add_basic", + "id": 13, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 9 + }, + [ + { + "Constant": { + "span": 106, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 10 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 9, + "id": 27 + } + } + }, + { + "Constant": { + "span": 107, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 20 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 9, + "id": 28 + } + } + }, + { + "Constant": { + "span": 108, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 30 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 9, + "id": 29 + } + } + }, + { + "Constant": { + "span": 109, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 40 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 9, + "id": 30 + } + } + } + ] + ] + } + ] + }, + "span": 110 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 111, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 31 + } + } + } + } + ] + }, + "span": 111 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 32 + } + } + } + } + ] + }, + "span": 105 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 105 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 105 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 115 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 115 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 112, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 61, + "id": 33 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 113, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 34 + } + } + } + ], + "destination": { + "local": 7, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 114 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 117 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 118, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 0 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 35 + } + } + } + } + ] + }, + "span": 118 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 119 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 120 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 121 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 122 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 123 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 116 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 116 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 124, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 61, + "id": 33 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 125, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 36 + } + } + } + ], + "destination": { + "local": 19, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 126 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 129 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 130 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 127, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 62, + "id": 37 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 128 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 21, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 19, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 132 + }, + { + "kind": { + "Assign": [ + { + "local": 22, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 133, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 1 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 38 + } + } + } + } + ] + }, + "span": 133 + }, + { + "kind": { + "Assign": [ + { + "local": 20, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 21, + "projection": [] + } + }, + { + "Move": { + "local": 22, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 134 + }, + { + "kind": { + "Assign": [ + { + "local": 23, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 135 + }, + { + "kind": { + "Assign": [ + { + "local": 24, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 136 + }, + { + "kind": { + "Assign": [ + { + "local": 26, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 23, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 137 + }, + { + "kind": { + "Assign": [ + { + "local": 27, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 24, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 138 + }, + { + "kind": { + "Assign": [ + { + "local": 25, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 26, + "projection": [] + } + }, + { + "Move": { + "local": 27, + "projection": [] + } + } + ] + } + ] + }, + "span": 131 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 25, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 7 + ] + ], + "otherwise": 6 + } + } + }, + "span": 131 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 139 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 28, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 142 + }, + { + "kind": { + "Assign": [ + { + "local": 30, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 143 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 140, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 62, + "id": 37 + } + } + }, + "args": [ + { + "Move": { + "local": 28, + "projection": [] + } + }, + { + "Copy": { + "local": 23, + "projection": [] + } + }, + { + "Copy": { + "local": 24, + "projection": [] + } + }, + { + "Move": { + "local": 30, + "projection": [] + } + } + ], + "destination": { + "local": 29, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 141 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 144, + "mutability": "Mut" + }, + { + "ty": 64, + "span": 145, + "mutability": "Not" + }, + { + "ty": 49, + "span": 146, + "mutability": "Not" + }, + { + "ty": 25, + "span": 115, + "mutability": "Not" + }, + { + "ty": 50, + "span": 111, + "mutability": "Not" + }, + { + "ty": 50, + "span": 105, + "mutability": "Mut" + }, + { + "ty": 65, + "span": 105, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 147, + "mutability": "Not" + }, + { + "ty": 66, + "span": 119, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 117, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 118, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 120, + "mutability": "Not" + }, + { + "ty": 25, + "span": 121, + "mutability": "Not" + }, + { + "ty": 65, + "span": 116, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 122, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 123, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 148, + "mutability": "Not" + }, + { + "ty": 55, + "span": 128, + "mutability": "Not" + }, + { + "ty": 57, + "span": 130, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 149, + "mutability": "Not" + }, + { + "ty": 66, + "span": 134, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 132, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 133, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 135, + "mutability": "Not" + }, + { + "ty": 25, + "span": 136, + "mutability": "Not" + }, + { + "ty": 65, + "span": 131, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 137, + "mutability": "Mut" + }, + { + "ty": 9, + "span": 138, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 150, + "mutability": "Not" + }, + { + "ty": 55, + "span": 141, + "mutability": "Not" + }, + { + "ty": 57, + "span": 143, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 145, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 146, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p1", + "source_info": { + "span": 147, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 120, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 121, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 148, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p3", + "source_info": { + "span": 149, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 135, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 23, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 136, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 24, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 150, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 28, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 151 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN7ptr_add19test_ptr_add_to_end17ha4fb2bee955d094eE", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_ptr_add_to_end", + "id": 17, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 32 + }, + [ + { + "Constant": { + "span": 219, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 100, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 51 + } + } + }, + { + "Constant": { + "span": 220, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 200, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 52 + } + } + }, + { + "Constant": { + "span": 221, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 44, + 1, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 32, + "id": 53 + } + } + } + ] + ] + } + ] + }, + "span": 222 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 223, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 31 + } + } + } + } + ] + }, + "span": 223 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 36 + } + } + } + } + ] + }, + "span": 218 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 218 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 218 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 227 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 227 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 224, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 71, + "id": 54 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 225, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 55 + } + } + } + ], + "destination": { + "local": 7, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 226 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 229 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 230, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 5 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 31, + "id": 56 + } + } + } + } + ] + }, + "span": 230 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 231 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 31 + ] + } + ] + } + } + } + ] + }, + "span": 232 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 31 + ] + } + ] + } + } + } + ] + }, + "span": 233 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 234 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 235 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 228 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 228 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 236 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 239 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 240 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 237, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 72, + "id": 57 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 238 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 241, + "mutability": "Mut" + }, + { + "ty": 73, + "span": 242, + "mutability": "Not" + }, + { + "ty": 52, + "span": 243, + "mutability": "Not" + }, + { + "ty": 31, + "span": 227, + "mutability": "Not" + }, + { + "ty": 50, + "span": 223, + "mutability": "Not" + }, + { + "ty": 50, + "span": 218, + "mutability": "Mut" + }, + { + "ty": 65, + "span": 218, + "mutability": "Mut" + }, + { + "ty": 52, + "span": 244, + "mutability": "Not" + }, + { + "ty": 74, + "span": 231, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 229, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 230, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 232, + "mutability": "Not" + }, + { + "ty": 31, + "span": 233, + "mutability": "Not" + }, + { + "ty": 65, + "span": 228, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 234, + "mutability": "Mut" + }, + { + "ty": 32, + "span": 235, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 245, + "mutability": "Not" + }, + { + "ty": 55, + "span": 238, + "mutability": "Not" + }, + { + "ty": 57, + "span": 240, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 242, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 243, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_end", + "source_info": { + "span": 244, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 232, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 233, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 245, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 246 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN7ptr_add21test_ptr_add_multiple17hedd97ab8e30aacffE", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_ptr_add_multiple", + "id": 16, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 153, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 39 + } + } + }, + { + "Constant": { + "span": 154, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 10, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 40 + } + } + }, + { + "Constant": { + "span": 155, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 15, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 41 + } + } + }, + { + "Constant": { + "span": 156, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 20, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 42 + } + } + }, + { + "Constant": { + "span": 157, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 25, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 43 + } + } + }, + { + "Constant": { + "span": 158, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 30, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 44 + } + } + } + ] + ] + } + ] + }, + "span": 159 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 160, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 31 + } + } + } + } + ] + }, + "span": 160 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 6, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 45 + } + } + } + } + ] + }, + "span": 152 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 152 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 152 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 164 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 164 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 161, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 67, + "id": 46 + } + } + }, + "args": [ + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 162, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 34 + } + } + } + ], + "destination": { + "local": 7, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 163 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 166 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 167, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 2 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 47 + } + } + } + } + ] + }, + "span": 167 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 168 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 169 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 170 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 171 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 172 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 165 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 165 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 173, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 67, + "id": 46 + } + } + }, + "args": [ + { + "Copy": { + "local": 7, + "projection": [] + } + }, + { + "Constant": { + "span": 174, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 34 + } + } + } + ], + "destination": { + "local": 19, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 175 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 178 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 179 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 176, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 68, + "id": 48 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 177 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 21, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 19, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 181 + }, + { + "kind": { + "Assign": [ + { + "local": 22, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 182, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 3 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 49 + } + } + } + } + ] + }, + "span": 182 + }, + { + "kind": { + "Assign": [ + { + "local": 20, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 21, + "projection": [] + } + }, + { + "Move": { + "local": 22, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 183 + }, + { + "kind": { + "Assign": [ + { + "local": 23, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 0, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 184 + }, + { + "kind": { + "Assign": [ + { + "local": 24, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 1, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 185 + }, + { + "kind": { + "Assign": [ + { + "local": 26, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 23, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 186 + }, + { + "kind": { + "Assign": [ + { + "local": 27, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 24, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 187 + }, + { + "kind": { + "Assign": [ + { + "local": 25, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 26, + "projection": [] + } + }, + { + "Move": { + "local": 27, + "projection": [] + } + } + ] + } + ] + }, + "span": 180 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 25, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 7 + ] + ], + "otherwise": 6 + } + } + }, + "span": 180 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 188, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 67, + "id": 46 + } + } + }, + "args": [ + { + "Copy": { + "local": 19, + "projection": [] + } + }, + { + "Constant": { + "span": 189, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 50, + "id": 34 + } + } + } + ], + "destination": { + "local": 31, + "projection": [] + }, + "target": 8, + "unwind": "Continue" + } + }, + "span": 190 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 28, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 193 + }, + { + "kind": { + "Assign": [ + { + "local": 30, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 194 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 191, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 68, + "id": 48 + } + } + }, + "args": [ + { + "Move": { + "local": 28, + "projection": [] + } + }, + { + "Copy": { + "local": 23, + "projection": [] + } + }, + { + "Copy": { + "local": 24, + "projection": [] + } + }, + { + "Move": { + "local": 30, + "projection": [] + } + } + ], + "destination": { + "local": 29, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 192 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 33, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 31, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 196 + }, + { + "kind": { + "Assign": [ + { + "local": 34, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 197, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 4 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 28, + "id": 50 + } + } + } + } + ] + }, + "span": 197 + }, + { + "kind": { + "Assign": [ + { + "local": 32, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 33, + "projection": [] + } + }, + { + "Move": { + "local": 34, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 198 + }, + { + "kind": { + "Assign": [ + { + "local": 35, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 32, + "projection": [ + { + "Field": [ + 0, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 199 + }, + { + "kind": { + "Assign": [ + { + "local": 36, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 32, + "projection": [ + { + "Field": [ + 1, + 28 + ] + } + ] + } + } + } + ] + }, + "span": 200 + }, + { + "kind": { + "Assign": [ + { + "local": 38, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 35, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 201 + }, + { + "kind": { + "Assign": [ + { + "local": 39, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 36, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 202 + }, + { + "kind": { + "Assign": [ + { + "local": 37, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 38, + "projection": [] + } + }, + { + "Move": { + "local": 39, + "projection": [] + } + } + ] + } + ] + }, + "span": 195 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 37, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 10 + ] + ], + "otherwise": 9 + } + } + }, + "span": 195 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 203 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 40, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 14, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 206 + }, + { + "kind": { + "Assign": [ + { + "local": 42, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 15, + 0, + [ + { + "Type": 63 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 207 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 204, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 68, + "id": 48 + } + } + }, + "args": [ + { + "Move": { + "local": 40, + "projection": [] + } + }, + { + "Copy": { + "local": 35, + "projection": [] + } + }, + { + "Copy": { + "local": 36, + "projection": [] + } + }, + { + "Move": { + "local": 42, + "projection": [] + } + } + ], + "destination": { + "local": 41, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 205 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 208, + "mutability": "Mut" + }, + { + "ty": 69, + "span": 209, + "mutability": "Not" + }, + { + "ty": 51, + "span": 210, + "mutability": "Not" + }, + { + "ty": 28, + "span": 164, + "mutability": "Not" + }, + { + "ty": 50, + "span": 160, + "mutability": "Not" + }, + { + "ty": 50, + "span": 152, + "mutability": "Mut" + }, + { + "ty": 65, + "span": 152, + "mutability": "Mut" + }, + { + "ty": 51, + "span": 211, + "mutability": "Not" + }, + { + "ty": 70, + "span": 168, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 166, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 167, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 169, + "mutability": "Not" + }, + { + "ty": 28, + "span": 170, + "mutability": "Not" + }, + { + "ty": 65, + "span": 165, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 171, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 172, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 212, + "mutability": "Not" + }, + { + "ty": 55, + "span": 177, + "mutability": "Not" + }, + { + "ty": 57, + "span": 179, + "mutability": "Mut" + }, + { + "ty": 51, + "span": 213, + "mutability": "Not" + }, + { + "ty": 70, + "span": 183, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 181, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 182, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 184, + "mutability": "Not" + }, + { + "ty": 28, + "span": 185, + "mutability": "Not" + }, + { + "ty": 65, + "span": 180, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 186, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 187, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 214, + "mutability": "Not" + }, + { + "ty": 55, + "span": 192, + "mutability": "Not" + }, + { + "ty": 57, + "span": 194, + "mutability": "Mut" + }, + { + "ty": 51, + "span": 215, + "mutability": "Not" + }, + { + "ty": 70, + "span": 198, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 196, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 197, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 199, + "mutability": "Not" + }, + { + "ty": 28, + "span": 200, + "mutability": "Not" + }, + { + "ty": 65, + "span": 195, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 201, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 202, + "mutability": "Mut" + }, + { + "ty": 56, + "span": 216, + "mutability": "Not" + }, + { + "ty": 55, + "span": 205, + "mutability": "Not" + }, + { + "ty": 57, + "span": 207, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 209, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 210, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p1", + "source_info": { + "span": 211, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 169, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 170, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 212, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p2", + "source_info": { + "span": 213, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 184, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 23, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 185, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 24, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 214, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 28, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p3", + "source_info": { + "span": 215, + "scope": 9 + }, + "composite": null, + "value": { + "Place": { + "local": 31, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 199, + "scope": 10 + }, + "composite": null, + "value": { + "Place": { + "local": 35, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 200, + "scope": 10 + }, + "composite": null, + "value": { + "Place": { + "local": 36, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 216, + "scope": 11 + }, + "composite": null, + "value": { + "Place": { + "local": 40, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 217 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN7ptr_add4main17h8a164a32007fdf15E", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 12, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 96, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 58, + "id": 24 + } + } + }, + "args": [], + "destination": { + "local": 1, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 97 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 98, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 59, + "id": 25 + } + } + }, + "args": [], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 99 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 100, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 60, + "id": 26 + } + } + }, + "args": [], + "destination": { + "local": 3, + "projection": [] + }, + "target": 3, + "unwind": "Continue" + } + }, + "span": 101 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 102 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 103, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 97, + "mutability": "Not" + }, + { + "ty": 1, + "span": 99, + "mutability": "Not" + }, + { + "ty": 1, + "span": 101, + "mutability": "Not" + } + ], + "arg_count": 0, + "var_debug_info": [], + "spread_arg": null, + "span": 104 + } + } + }, + "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": 105, + "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": 49, + "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": 29, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 6 + ], + [ + 55 + ] + ], + "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": 70, + "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": 68, + "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, + { + "EnumType": { + "name": "std::result::Result<(), std::fmt::Error>", + "adt_def": 29, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 1 + ], + [ + 81 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 23, + { + "RefType": { + "pointee_type": 25, + "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 + } + } + } + } + ], + [ + 24, + { + "RefType": { + "pointee_type": 75, + "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, + { + "RefType": { + "pointee_type": 9, + "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 + } + } + } + } + ], + [ + 27, + { + "RefType": { + "pointee_type": 28, + "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 + } + } + } + } + ], + [ + 28, + { + "RefType": { + "pointee_type": 16, + "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, + { + "RefType": { + "pointee_type": 31, + "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, + { + "RefType": { + "pointee_type": 32, + "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 + } + } + } + } + ], + [ + 32, + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + 43, + { + "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 + } + } + } + } + ], + [ + 45, + { + "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 + } + } + } + } + ], + [ + 46, + { + "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 + } + } + } + } + ], + [ + 47, + { + "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 + } + } + } + } + ], + [ + 48, + { + "PtrType": { + "pointee_type": 31, + "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 + } + } + } + } + ], + [ + 49, + { + "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 + } + } + } + } + ], + [ + 50, + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + 51, + { + "PtrType": { + "pointee_type": 16, + "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 + } + } + } + } + ], + [ + 52, + { + "PtrType": { + "pointee_type": 32, + "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 + } + } + } + } + ], + [ + 54, + { + "RefType": { + "pointee_type": 83, + "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 + } + } + } + } + ], + [ + 55, + "VoidType" + ], + [ + 56, + { + "EnumType": { + "name": "core::panicking::AssertKind", + "adt_def": 14, + "discriminants": [ + 0, + 1, + 2 + ], + "fields": [ + [], + [], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 57, + { + "EnumType": { + "name": "std::option::Option>", + "adt_def": 15, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 63 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 1, + "niche_variants": { + "start": 0, + "end": 0 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + ] + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + } + } + ], + [ + 63, + { + "StructType": { + "name": "std::fmt::Arguments<'_>", + "adt_def": 37, + "fields": [ + 85, + 86, + 87 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 256 + }, + { + "num_bits": 128 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + } + } + ], + [ + 64, + { + "ArrayType": { + "elem_type": 9, + "size": { + "kind": { + "Value": [ + 50, + { + "bytes": [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 1 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 8 + }, + "count": 4 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 32 + } + } + } + } + ], + [ + 65, + { + "PrimitiveType": "Bool" + } + ], + [ + 66, + { + "TupleType": { + "types": [ + 25, + 25 + ], + "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 + } + } + } + } + ], + [ + 69, + { + "ArrayType": { + "elem_type": 16, + "size": { + "kind": { + "Value": [ + 50, + { + "bytes": [ + 6, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 2 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 6 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 192 + } + } + } + } + ], + [ + 70, + { + "TupleType": { + "types": [ + 28, + 28 + ], + "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 + } + } + } + } + ], + [ + 73, + { + "ArrayType": { + "elem_type": 32, + "size": { + "kind": { + "Value": [ + 50, + { + "bytes": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 0 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 3 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 96 + } + } + } + } + ], + [ + 74, + { + "TupleType": { + "types": [ + 31, + 31 + ], + "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 + } + } + } + } + ], + [ + 75, + { + "StructType": { + "name": "std::fmt::Formatter<'_>", + "adt_def": 19, + "fields": [ + 32, + 76, + 77, + 78, + 78, + 79 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 416 + }, + { + "num_bits": 384 + }, + { + "num_bits": 448 + }, + { + "num_bits": 0 + }, + { + "num_bits": 128 + }, + { + "num_bits": 256 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 512 + } + } + } + } + ], + [ + 76, + { + "PrimitiveType": "Char" + } + ], + [ + 77, + { + "EnumType": { + "name": "core::fmt::rt::Alignment", + "adt_def": 26, + "discriminants": [ + 0, + 1, + 2, + 3 + ], + "fields": [ + [], + [], + [], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 3 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 3 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 3 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 78, + { + "EnumType": { + "name": "std::option::Option", + "adt_def": 15, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 50 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 64 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 79, + { + "RefType": { + "pointee_type": 80, + "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 + } + } + } + } + ], + [ + 81, + { + "StructType": { + "name": "std::fmt::Error", + "adt_def": 32, + "fields": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 84, + { + "RefType": { + "pointee_type": 104, + "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 + } + } + } + } + ], + [ + 85, + { + "RefType": { + "pointee_type": 88, + "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 + } + } + } + } + ], + [ + 86, + { + "EnumType": { + "name": "std::option::Option<&[core::fmt::rt::Placeholder]>", + "adt_def": 15, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 91 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 1, + "niche_variants": { + "start": 0, + "end": 0 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "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 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 87, + { + "RefType": { + "pointee_type": 95, + "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 + } + } + } + } + ], + [ + 88, + { + "ArrayType": { + "elem_type": 89, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 128 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 89, + { + "RefType": { + "pointee_type": 90, + "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 + } + } + } + } + ], + [ + 90, + { + "PrimitiveType": "Str" + } + ], + [ + 91, + { + "RefType": { + "pointee_type": 92, + "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 + } + } + } + } + ], + [ + 92, + { + "ArrayType": { + "elem_type": 93, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 448 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 93, + { + "StructType": { + "name": "core::fmt::rt::Placeholder", + "adt_def": 41, + "fields": [ + 50, + 76, + 77, + 32, + 94, + 94 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 256 + }, + { + "num_bits": 320 + }, + { + "num_bits": 384 + }, + { + "num_bits": 352 + }, + { + "num_bits": 0 + }, + { + "num_bits": 128 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 448 + } + } + } + } + ], + [ + 94, + { + "EnumType": { + "name": "core::fmt::rt::Count", + "adt_def": 48, + "discriminants": [ + 0, + 1, + 2 + ], + "fields": [ + [ + 50 + ], + [ + 50 + ], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 64 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 95, + { + "ArrayType": { + "elem_type": 96, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 128 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 96, + { + "StructType": { + "name": "core::fmt::rt::Argument<'_>", + "adt_def": 51, + "fields": [ + 97 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 97, + { + "EnumType": { + "name": "core::fmt::rt::ArgumentType<'_>", + "adt_def": 53, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 98, + 99, + 100 + ], + [ + 50 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 0, + "niche_variants": { + "start": 1, + "end": 1 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + }, + { + "num_bits": 128 + } + ] + } + }, + "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 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + ] + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 98, + { + "StructType": { + "name": "std::ptr::NonNull<()>", + "adt_def": 58, + "fields": [ + 101 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 100, + { + "StructType": { + "name": "std::marker::PhantomData<&()>", + "adt_def": 60, + "fields": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 101, + { + "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 + } + } + } + } + ], + [ + 103, + { + "RefType": { + "pointee_type": 1, + "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 + } + } + } + } + ], + [ + 104, + { + "StructType": { + "name": "std::panic::Location<'_>", + "adt_def": 61, + "fields": [ + 89, + 32, + 32 + ], + "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 + } + } + } + } + ] + ], + "spans": [ + [ + 0, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 62, + 2393, + 70 + ] + ], + [ + 44, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 62, + 2393, + 82 + ] + ], + [ + 45, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 71, + 2393, + 78 + ] + ], + [ + 46, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 84, + 2393, + 84 + ] + ], + [ + 48, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 20, + 2393, + 25 + ] + ], + [ + 49, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 27, + 2393, + 28 + ] + ], + [ + 50, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 13, + 2393, + 84 + ] + ], + [ + 51, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 181, + 24, + 181, + 43 + ] + ], + [ + 52, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 9, + 1937, + 59 + ] + ], + [ + 53, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 9, + 1937, + 19 + ] + ], + [ + 54, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 58, + 1937, + 59 + ] + ], + [ + 55, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 182, + 25, + 182, + 43 + ] + ], + [ + 56, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 182, + 25, + 182, + 52 + ] + ], + [ + 57, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 183, + 31, + 183, + 50 + ] + ], + [ + 58, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 9, + 1941, + 59 + ] + ], + [ + 59, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 9, + 1941, + 19 + ] + ], + [ + 60, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 58, + 1941, + 59 + ] + ], + [ + 61, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 184, + 25, + 184, + 43 + ] + ], + [ + 62, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 184, + 25, + 184, + 52 + ] + ], + [ + 63, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 186, + 25, + 186, + 42 + ] + ], + [ + 64, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 186, + 25, + 186, + 51 + ] + ], + [ + 65, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 181, + 21, + 187, + 22 + ] + ], + [ + 66, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 188, + 18, + 188, + 18 + ] + ], + [ + 68, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 24, + 180, + 29 + ] + ], + [ + 69, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 31, + 180, + 32 + ] + ], + [ + 70, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1936, + 24, + 1936, + 29 + ] + ], + [ + 71, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1940, + 24, + 1940, + 29 + ] + ], + [ + 72, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 17, + 188, + 18 + ] + ], + [ + 73, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", + 250, + 5, + 250, + 71 + ] + ], + [ + 74, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", + 521, + 1, + 521, + 56 + ] + ], + [ + 75, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 952, + 6, + 952, + 6 + ] + ], + [ + 76, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 951, + 18, + 951, + 49 + ] + ], + [ + 78, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 917, + 29, + 917, + 33 + ] + ], + [ + 79, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 917, + 35, + 917, + 40 + ] + ], + [ + 80, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs", + 917, + 5, + 952, + 6 + ] + ], + [ + 81, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 5, + 373, + 24 + ] + ], + [ + 82, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 5, + 373, + 51 + ] + ], + [ + 83, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 31, + 373, + 36 + ] + ], + [ + 84, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 38, + 373, + 44 + ] + ], + [ + 86, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 364, + 5, + 364, + 9 + ] + ], + [ + 87, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 365, + 5, + 365, + 9 + ] + ], + [ + 88, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 366, + 5, + 366, + 10 + ] + ], + [ + 89, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 367, + 5, + 367, + 9 + ] + ], + [ + 90, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 363, + 1, + 374, + 2 + ] + ], + [ + 91, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 92, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 94, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 95, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 96, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 2, + 5, + 2, + 23 + ] + ], + [ + 97, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 2, + 5, + 2, + 25 + ] + ], + [ + 98, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 3, + 5, + 3, + 26 + ] + ], + [ + 99, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 3, + 5, + 3, + 28 + ] + ], + [ + 100, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 4, + 5, + 4, + 24 + ] + ], + [ + 101, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 4, + 5, + 4, + 26 + ] + ], + [ + 102, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 5, + 2, + 5, + 2 + ] + ], + [ + 104, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 1, + 1, + 5, + 2 + ] + ], + [ + 105, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 10, + 16, + 10, + 22 + ] + ], + [ + 106, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 16, + 9, + 20 + ] + ], + [ + 107, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 22, + 9, + 24 + ] + ], + [ + 108, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 26, + 9, + 28 + ] + ], + [ + 109, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 30, + 9, + 32 + ] + ], + [ + 110, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 15, + 9, + 33 + ] + ], + [ + 111, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 10, + 20, + 10, + 21 + ] + ], + [ + 112, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 13, + 22, + 13, + 25 + ] + ], + [ + 113, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 13, + 26, + 13, + 27 + ] + ], + [ + 114, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 13, + 18, + 13, + 28 + ] + ], + [ + 115, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 10, + 15, + 10, + 22 + ] + ], + [ + 116, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 117, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 118, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 119, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 120, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 121, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 122, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 123, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 124, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 16, + 22, + 16, + 25 + ] + ], + [ + 125, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 16, + 26, + 16, + 27 + ] + ], + [ + 126, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 16, + 18, + 16, + 28 + ] + ], + [ + 127, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 128, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 129, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 130, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 131, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 132, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 133, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 134, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 135, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 136, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 137, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 138, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 139, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 19, + 2, + 19, + 2 + ] + ], + [ + 140, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 141, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 142, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 143, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 145, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 9, + 9, + 9, + 12 + ] + ], + [ + 146, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 10, + 9, + 10, + 12 + ] + ], + [ + 147, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 13, + 13, + 13, + 15 + ] + ], + [ + 148, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 149, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 16, + 13, + 16, + 15 + ] + ], + [ + 150, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 151, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 8, + 1, + 19, + 2 + ] + ], + [ + 152, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 24, + 16, + 24, + 22 + ] + ], + [ + 153, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 16, + 23, + 20 + ] + ], + [ + 154, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 22, + 23, + 24 + ] + ], + [ + 155, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 26, + 23, + 28 + ] + ], + [ + 156, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 30, + 23, + 32 + ] + ], + [ + 157, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 34, + 23, + 36 + ] + ], + [ + 158, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 38, + 23, + 40 + ] + ], + [ + 159, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 15, + 23, + 41 + ] + ], + [ + 160, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 24, + 20, + 24, + 21 + ] + ], + [ + 161, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 27, + 22, + 27, + 25 + ] + ], + [ + 162, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 27, + 26, + 27, + 27 + ] + ], + [ + 163, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 27, + 18, + 27, + 28 + ] + ], + [ + 164, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 24, + 15, + 24, + 22 + ] + ], + [ + 165, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 166, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 167, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 168, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 169, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 170, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 171, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 172, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 173, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 30, + 21, + 30, + 24 + ] + ], + [ + 174, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 30, + 25, + 30, + 26 + ] + ], + [ + 175, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 30, + 18, + 30, + 27 + ] + ], + [ + 176, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 177, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 178, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 179, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 180, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 181, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 182, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 183, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 184, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 185, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 186, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 187, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 188, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 33, + 21, + 33, + 24 + ] + ], + [ + 189, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 33, + 25, + 33, + 26 + ] + ], + [ + 190, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 33, + 18, + 33, + 27 + ] + ], + [ + 191, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 192, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 193, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 194, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 195, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 196, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 197, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 198, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 199, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 200, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 201, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 202, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 203, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 36, + 2, + 36, + 2 + ] + ], + [ + 204, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 205, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 206, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 207, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 209, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 23, + 9, + 23, + 12 + ] + ], + [ + 210, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 24, + 9, + 24, + 12 + ] + ], + [ + 211, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 27, + 13, + 27, + 15 + ] + ], + [ + 212, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 213, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 30, + 13, + 30, + 15 + ] + ], + [ + 214, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 215, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 33, + 13, + 33, + 15 + ] + ], + [ + 216, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 217, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 22, + 1, + 36, + 2 + ] + ], + [ + 218, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 41, + 16, + 41, + 22 + ] + ], + [ + 219, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 40, + 16, + 40, + 22 + ] + ], + [ + 220, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 40, + 24, + 40, + 27 + ] + ], + [ + 221, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 40, + 29, + 40, + 32 + ] + ], + [ + 222, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 40, + 15, + 40, + 33 + ] + ], + [ + 223, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 41, + 20, + 41, + 21 + ] + ], + [ + 224, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 44, + 25, + 44, + 28 + ] + ], + [ + 225, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 44, + 29, + 44, + 30 + ] + ], + [ + 226, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 44, + 21, + 44, + 31 + ] + ], + [ + 227, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 41, + 15, + 41, + 22 + ] + ], + [ + 228, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 229, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 230, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 231, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 232, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 233, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 234, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 235, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 236, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 47, + 2, + 47, + 2 + ] + ], + [ + 237, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 238, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 239, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 240, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 242, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 40, + 9, + 40, + 12 + ] + ], + [ + 243, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 41, + 9, + 41, + 12 + ] + ], + [ + 244, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 44, + 13, + 44, + 18 + ] + ], + [ + 245, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 246, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-add.rs", + 39, + 1, + 47, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.state b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.state new file mode 100644 index 000000000..2b0214a0e --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-add.state @@ -0,0 +1,74 @@ + + + operandConstant ( constOperand (... span: span ( 113 ) , 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 ( 50 ) , id: mirConstId ( 34 ) ) ) ) ~> #freezer#setLocalValue(_,_)_RT-DATA_KItem_Place_Evaluation1_ ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ~> .K ) ~> #setArgsFromStack ( 3 , .Operands ) ~> #execBlock ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 1 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 76 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 75 ) ) ) ) ~> .K + + + noReturn + + + ty ( 61 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 0 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 1 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 76 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 75 ) ) ) ) + + + ty ( 58 ) + + + place (... local: local ( 7 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 2 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 49 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) , ty ( 49 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 50 ) , mutabilityNot ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 1 ) , projection: .ProjectionElems ) , someBasicBlockIdx ( basicBlockIdx ( 1 ) ) , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Range ( ListItem ( Integer ( 10 , 8 , false ) ) + ListItem ( Integer ( 20 , 8 , false ) ) + ListItem ( Integer ( 30 , 8 , false ) ) + ListItem ( Integer ( 40 , 8 , false ) ) ) , ty ( 64 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) , ty ( 49 ) , mutabilityNot ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 25 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 0 , 64 , false ) , ty ( 50 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 4 , 64 , false ) , ty ( 50 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 65 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 49 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 66 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 65 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 9 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 9 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 56 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 55 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 57 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 49 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 66 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 65 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 9 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 9 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 56 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 55 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 57 ) , mutabilityMut ) ) ) ) + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) ) ) + 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/ptr-offset-basic.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-basic.smir.json new file mode 100644 index 000000000..188237dab --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-basic.smir.json @@ -0,0 +1,13648 @@ +{ + "name": "ptr_offset_basic", + "crate_id": 2257544609172700868, + "allocs": [ + { + "alloc_id": 0, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 1, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 2, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 3, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 4, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 20, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 5, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 30, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + }, + { + "alloc_id": 6, + "ty": 16, + "global_alloc": { + "Memory": { + "bytes": [ + 40, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Not" + } + } + } + ], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17hdef7e1fa9f62bfa1E" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h53e1e5f50ff28559E" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h42df40f4886b05f7E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i32$GT$3fmt17h349a8b3b9d886ac3E" + } + ], + [ + 27, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i32$GT$3fmt17h525d1efda5babc1eE" + } + ], + [ + 28, + { + "NormalSym": "_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i32$GT$3fmt17h023afc4914ab0634E" + } + ], + [ + 29, + { + "NormalSym": "_ZN4core3fmt3num3imp52_$LT$impl$u20$core..fmt..Display$u20$for$u20$i32$GT$3fmt17h60f99ce8b93bf8c3E" + } + ], + [ + 30, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h880dba0474f28974E" + } + ], + [ + 32, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17hf85973269d63cf9dE" + } + ], + [ + 35, + { + "NormalSym": "_ZN4core9panicking19assert_failed_inner17h45dfcec0d802af65E" + } + ], + [ + 40, + { + "NormalSym": "_ZN16ptr_offset_basic16test_offset_zero17h37f75551591e6f55E" + } + ], + [ + 41, + { + "NormalSym": "_ZN16ptr_offset_basic20test_offset_positive17hd1bd4788ec98f6dfE" + } + ], + [ + 42, + { + "NormalSym": "_ZN16ptr_offset_basic18test_offset_to_end17he122600f42395471E" + } + ], + [ + 43, + { + "NormalSym": "_ZN16ptr_offset_basic20test_offset_negative17h84d8ece40b811e9dE" + } + ], + [ + 45, + { + "NormalSym": "_ZN4core9panicking13assert_failed17h2897bbde3c223800E" + } + ], + [ + 80, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN16ptr_offset_basic16test_offset_zero17h37f75551591e6f55E", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_offset_zero", + "id": 10, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 102, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 20 + } + } + }, + { + "Constant": { + "span": 103, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 21 + } + } + }, + { + "Constant": { + "span": 104, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 22 + } + } + }, + { + "Constant": { + "span": 105, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 23 + } + } + }, + { + "Constant": { + "span": 106, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 24 + } + } + } + ] + ] + } + ] + }, + "span": 107 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 108, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 25 + } + } + } + } + ] + }, + "span": 108 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 26 + } + } + } + } + ] + }, + "span": 101 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 101 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 101 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 110 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 110 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 111, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 27 + } + } + } + ] + } + ] + }, + "span": 112 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 113 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 114, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 0 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 28 + } + } + } + } + ] + }, + "span": 114 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 115 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 116 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 117 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 118 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 119 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 109 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 3 + ] + ], + "otherwise": 2 + } + } + }, + "span": 109 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 120 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 123 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 124 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 121, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 122 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 125, + "mutability": "Mut" + }, + { + "ty": 47, + "span": 126, + "mutability": "Not" + }, + { + "ty": 48, + "span": 127, + "mutability": "Not" + }, + { + "ty": 25, + "span": 110, + "mutability": "Not" + }, + { + "ty": 44, + "span": 108, + "mutability": "Not" + }, + { + "ty": 44, + "span": 101, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 101, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 128, + "mutability": "Not" + }, + { + "ty": 50, + "span": 115, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 113, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 114, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 116, + "mutability": "Not" + }, + { + "ty": 25, + "span": 117, + "mutability": "Not" + }, + { + "ty": 49, + "span": 109, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 118, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 119, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 129, + "mutability": "Not" + }, + { + "ty": 37, + "span": 122, + "mutability": "Not" + }, + { + "ty": 39, + "span": 124, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 126, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 127, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p0", + "source_info": { + "span": 128, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 116, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 117, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 129, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 130 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16ptr_offset_basic18test_offset_to_end17he122600f42395471E", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_offset_to_end", + "id": 14, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 178, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 20 + } + } + }, + { + "Constant": { + "span": 179, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 21 + } + } + }, + { + "Constant": { + "span": 180, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 22 + } + } + }, + { + "Constant": { + "span": 181, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 23 + } + } + }, + { + "Constant": { + "span": 182, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 24 + } + } + } + ] + ] + } + ] + }, + "span": 183 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 184, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 25 + } + } + } + } + ] + }, + "span": 184 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 26 + } + } + } + } + ] + }, + "span": 177 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 177 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 177 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 186 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 186 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 187, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 34 + } + } + } + ] + } + ] + }, + "span": 188 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 189 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 190, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 3 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 35 + } + } + } + } + ] + }, + "span": 190 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 191 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 192 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 193 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 194 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 195 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 185 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 3 + ] + ], + "otherwise": 2 + } + } + }, + "span": 185 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 196 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 199 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 200 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 197, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 198 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 201, + "mutability": "Mut" + }, + { + "ty": 47, + "span": 202, + "mutability": "Not" + }, + { + "ty": 48, + "span": 203, + "mutability": "Not" + }, + { + "ty": 25, + "span": 186, + "mutability": "Not" + }, + { + "ty": 44, + "span": 184, + "mutability": "Not" + }, + { + "ty": 44, + "span": 177, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 177, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 204, + "mutability": "Not" + }, + { + "ty": 50, + "span": 191, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 189, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 190, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 192, + "mutability": "Not" + }, + { + "ty": 25, + "span": 193, + "mutability": "Not" + }, + { + "ty": 49, + "span": 185, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 194, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 195, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 205, + "mutability": "Not" + }, + { + "ty": 37, + "span": 198, + "mutability": "Not" + }, + { + "ty": 39, + "span": 200, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 202, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 203, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p4", + "source_info": { + "span": 204, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 192, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 193, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 205, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 206 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16ptr_offset_basic20test_offset_negative17h84d8ece40b811e9dE", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_offset_negative", + "id": 15, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 208, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 10, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 36 + } + } + }, + { + "Constant": { + "span": 209, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 20, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 37 + } + } + }, + { + "Constant": { + "span": 210, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 30, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 38 + } + } + }, + { + "Constant": { + "span": 211, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 40, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 39 + } + } + }, + { + "Constant": { + "span": 212, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 50, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 40 + } + } + } + ] + ] + } + ] + }, + "span": 213 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 214, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 41 + } + } + } + } + ] + }, + "span": 214 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 26 + } + } + } + } + ] + }, + "span": 207 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 207 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 207 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 216 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 216 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 217, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 254, + 255, + 255, + 255, + 255, + 255, + 255, + 255 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 42 + } + } + } + ] + } + ] + }, + "span": 218 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 219 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 220, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 4 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 43 + } + } + } + } + ] + }, + "span": 220 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 221 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 222 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 223 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 224 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 225 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 215 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 3 + ] + ], + "otherwise": 2 + } + } + }, + "span": 215 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 19, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 227, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 255, + 255, + 255, + 255, + 255, + 255, + 255, + 255 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 44 + } + } + } + ] + } + ] + }, + "span": 228 + }, + { + "kind": { + "Assign": [ + { + "local": 21, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 19, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 229 + }, + { + "kind": { + "Assign": [ + { + "local": 22, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 230, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 5 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 45 + } + } + } + } + ] + }, + "span": 230 + }, + { + "kind": { + "Assign": [ + { + "local": 20, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 21, + "projection": [] + } + }, + { + "Move": { + "local": 22, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 231 + }, + { + "kind": { + "Assign": [ + { + "local": 23, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 232 + }, + { + "kind": { + "Assign": [ + { + "local": 24, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 233 + }, + { + "kind": { + "Assign": [ + { + "local": 26, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 23, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 234 + }, + { + "kind": { + "Assign": [ + { + "local": 27, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 24, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 235 + }, + { + "kind": { + "Assign": [ + { + "local": 25, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 26, + "projection": [] + } + }, + { + "Move": { + "local": 27, + "projection": [] + } + } + ] + } + ] + }, + "span": 226 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 25, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 5 + ] + ], + "otherwise": 4 + } + } + }, + "span": 226 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 238 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 239 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 236, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 237 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 31, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 241, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 27 + } + } + } + ] + } + ] + }, + "span": 242 + }, + { + "kind": { + "Assign": [ + { + "local": 33, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 31, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 243 + }, + { + "kind": { + "Assign": [ + { + "local": 34, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 244, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 6 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 46 + } + } + } + } + ] + }, + "span": 244 + }, + { + "kind": { + "Assign": [ + { + "local": 32, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 33, + "projection": [] + } + }, + { + "Move": { + "local": 34, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 245 + }, + { + "kind": { + "Assign": [ + { + "local": 35, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 32, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 246 + }, + { + "kind": { + "Assign": [ + { + "local": 36, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 32, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 247 + }, + { + "kind": { + "Assign": [ + { + "local": 38, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 35, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 248 + }, + { + "kind": { + "Assign": [ + { + "local": 39, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 36, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 249 + }, + { + "kind": { + "Assign": [ + { + "local": 37, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 38, + "projection": [] + } + }, + { + "Move": { + "local": 39, + "projection": [] + } + } + ] + } + ] + }, + "span": 240 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 37, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 7 + ] + ], + "otherwise": 6 + } + } + }, + "span": 240 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 28, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 252 + }, + { + "kind": { + "Assign": [ + { + "local": 30, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 253 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 250, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 28, + "projection": [] + } + }, + { + "Copy": { + "local": 23, + "projection": [] + } + }, + { + "Copy": { + "local": 24, + "projection": [] + } + }, + { + "Move": { + "local": 30, + "projection": [] + } + } + ], + "destination": { + "local": 29, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 251 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 254 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 40, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 257 + }, + { + "kind": { + "Assign": [ + { + "local": 42, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 258 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 255, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 40, + "projection": [] + } + }, + { + "Copy": { + "local": 35, + "projection": [] + } + }, + { + "Copy": { + "local": 36, + "projection": [] + } + }, + { + "Move": { + "local": 42, + "projection": [] + } + } + ], + "destination": { + "local": 41, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 256 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 259, + "mutability": "Mut" + }, + { + "ty": 47, + "span": 260, + "mutability": "Not" + }, + { + "ty": 48, + "span": 261, + "mutability": "Not" + }, + { + "ty": 25, + "span": 216, + "mutability": "Not" + }, + { + "ty": 44, + "span": 214, + "mutability": "Not" + }, + { + "ty": 44, + "span": 207, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 207, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 262, + "mutability": "Not" + }, + { + "ty": 50, + "span": 221, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 219, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 220, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 222, + "mutability": "Not" + }, + { + "ty": 25, + "span": 223, + "mutability": "Not" + }, + { + "ty": 49, + "span": 215, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 224, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 225, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 263, + "mutability": "Not" + }, + { + "ty": 37, + "span": 237, + "mutability": "Not" + }, + { + "ty": 39, + "span": 239, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 264, + "mutability": "Not" + }, + { + "ty": 50, + "span": 231, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 229, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 230, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 232, + "mutability": "Not" + }, + { + "ty": 25, + "span": 233, + "mutability": "Not" + }, + { + "ty": 49, + "span": 226, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 234, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 235, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 265, + "mutability": "Not" + }, + { + "ty": 37, + "span": 251, + "mutability": "Not" + }, + { + "ty": 39, + "span": 253, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 266, + "mutability": "Not" + }, + { + "ty": 50, + "span": 245, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 243, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 244, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 246, + "mutability": "Not" + }, + { + "ty": 25, + "span": 247, + "mutability": "Not" + }, + { + "ty": 49, + "span": 240, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 248, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 249, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 267, + "mutability": "Not" + }, + { + "ty": 37, + "span": 256, + "mutability": "Not" + }, + { + "ty": 39, + "span": 258, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 260, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 261, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_back", + "source_info": { + "span": 262, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 222, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 223, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 263, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_back1", + "source_info": { + "span": 264, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 232, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 23, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 233, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 24, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 265, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 28, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_same", + "source_info": { + "span": 266, + "scope": 9 + }, + "composite": null, + "value": { + "Place": { + "local": 31, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 246, + "scope": 10 + }, + "composite": null, + "value": { + "Place": { + "local": 35, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 247, + "scope": 10 + }, + "composite": null, + "value": { + "Place": { + "local": 36, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 267, + "scope": 11 + }, + "composite": null, + "value": { + "Place": { + "local": 40, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 268 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16ptr_offset_basic20test_offset_positive17hd1bd4788ec98f6dfE", + "mono_item_kind": { + "MonoItemFn": { + "name": "test_offset_positive", + "id": 13, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 132, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 20 + } + } + }, + { + "Constant": { + "span": 133, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 21 + } + } + }, + { + "Constant": { + "span": 134, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 22 + } + } + }, + { + "Constant": { + "span": 135, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 23 + } + } + }, + { + "Constant": { + "span": 136, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 24 + } + } + } + ] + ] + } + ] + }, + "span": 137 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 138, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 25 + } + } + } + } + ] + }, + "span": 138 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 44, + "id": 26 + } + } + } + } + ] + }, + "span": 131 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 131 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 131 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 140 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 140 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 141, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 30 + } + } + } + ] + } + ] + }, + "span": 142 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 7, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 143 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 144, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 1 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 31 + } + } + } + } + ] + }, + "span": 144 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 9, + "projection": [] + } + }, + { + "Move": { + "local": 10, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 145 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 146 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 8, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 147 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 11, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 148 + }, + { + "kind": { + "Assign": [ + { + "local": 15, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 12, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 149 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 14, + "projection": [] + } + }, + { + "Move": { + "local": 15, + "projection": [] + } + } + ] + } + ] + }, + "span": 139 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 13, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 3 + ] + ], + "otherwise": 2 + } + } + }, + "span": 139 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 19, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 151, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 32 + } + } + } + ] + } + ] + }, + "span": 152 + }, + { + "kind": { + "Assign": [ + { + "local": 21, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 19, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 153 + }, + { + "kind": { + "Assign": [ + { + "local": 22, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 154, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [ + [ + 0, + 2 + ] + ] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 33 + } + } + } + } + ] + }, + "span": 154 + }, + { + "kind": { + "Assign": [ + { + "local": 20, + "projection": [] + }, + { + "Aggregate": [ + "Tuple", + [ + { + "Move": { + "local": 21, + "projection": [] + } + }, + { + "Move": { + "local": 22, + "projection": [] + } + } + ] + ] + } + ] + }, + "span": 155 + }, + { + "kind": { + "Assign": [ + { + "local": 23, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 0, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 156 + }, + { + "kind": { + "Assign": [ + { + "local": 24, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 20, + "projection": [ + { + "Field": [ + 1, + 25 + ] + } + ] + } + } + } + ] + }, + "span": 157 + }, + { + "kind": { + "Assign": [ + { + "local": 26, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 23, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 158 + }, + { + "kind": { + "Assign": [ + { + "local": 27, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 24, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 159 + }, + { + "kind": { + "Assign": [ + { + "local": 25, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Move": { + "local": 26, + "projection": [] + } + }, + { + "Move": { + "local": 27, + "projection": [] + } + } + ] + } + ] + }, + "span": 150 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 25, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 5 + ] + ], + "otherwise": 4 + } + } + }, + "span": 150 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 16, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 162 + }, + { + "kind": { + "Assign": [ + { + "local": 18, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 163 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 160, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 16, + "projection": [] + } + }, + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + }, + { + "Move": { + "local": 18, + "projection": [] + } + } + ], + "destination": { + "local": 17, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 161 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 164 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 28, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 11, + 0, + [], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 167 + }, + { + "kind": { + "Assign": [ + { + "local": 30, + "projection": [] + }, + { + "Aggregate": [ + { + "Adt": [ + 12, + 0, + [ + { + "Type": 46 + } + ], + null, + null + ] + }, + [] + ] + } + ] + }, + "span": 168 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 165, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 45, + "id": 29 + } + } + }, + "args": [ + { + "Move": { + "local": 28, + "projection": [] + } + }, + { + "Copy": { + "local": 23, + "projection": [] + } + }, + { + "Copy": { + "local": 24, + "projection": [] + } + }, + { + "Move": { + "local": 30, + "projection": [] + } + } + ], + "destination": { + "local": 29, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 166 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 169, + "mutability": "Mut" + }, + { + "ty": 47, + "span": 170, + "mutability": "Not" + }, + { + "ty": 48, + "span": 171, + "mutability": "Not" + }, + { + "ty": 25, + "span": 140, + "mutability": "Not" + }, + { + "ty": 44, + "span": 138, + "mutability": "Not" + }, + { + "ty": 44, + "span": 131, + "mutability": "Mut" + }, + { + "ty": 49, + "span": 131, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 172, + "mutability": "Not" + }, + { + "ty": 50, + "span": 145, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 143, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 144, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 146, + "mutability": "Not" + }, + { + "ty": 25, + "span": 147, + "mutability": "Not" + }, + { + "ty": 49, + "span": 139, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 148, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 149, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 173, + "mutability": "Not" + }, + { + "ty": 37, + "span": 161, + "mutability": "Not" + }, + { + "ty": 39, + "span": 163, + "mutability": "Mut" + }, + { + "ty": 48, + "span": 174, + "mutability": "Not" + }, + { + "ty": 50, + "span": 155, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 153, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 154, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 156, + "mutability": "Not" + }, + { + "ty": 25, + "span": 157, + "mutability": "Not" + }, + { + "ty": 49, + "span": 150, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 158, + "mutability": "Mut" + }, + { + "ty": 16, + "span": 159, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 175, + "mutability": "Not" + }, + { + "ty": 37, + "span": 166, + "mutability": "Not" + }, + { + "ty": 39, + "span": 168, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 170, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 171, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p2", + "source_info": { + "span": 172, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 146, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 11, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 147, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 12, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 173, + "scope": 5 + }, + "composite": null, + "value": { + "Place": { + "local": 16, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p3", + "source_info": { + "span": 174, + "scope": 6 + }, + "composite": null, + "value": { + "Place": { + "local": 19, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "left_val", + "source_info": { + "span": 156, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 23, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "right_val", + "source_info": { + "span": 157, + "scope": 7 + }, + "composite": null, + "value": { + "Place": { + "local": 24, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "kind", + "source_info": { + "span": 175, + "scope": 8 + }, + "composite": null, + "value": { + "Place": { + "local": 28, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 176 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN16ptr_offset_basic4main17h8df18458b64b2f83E", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 9, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 90, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 40, + "id": 16 + } + } + }, + "args": [], + "destination": { + "local": 1, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 91 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 92, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 41, + "id": 17 + } + } + }, + "args": [], + "destination": { + "local": 2, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 93 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 94, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 42, + "id": 18 + } + } + }, + "args": [], + "destination": { + "local": 3, + "projection": [] + }, + "target": 3, + "unwind": "Continue" + } + }, + "span": 95 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 96, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 43, + "id": 19 + } + } + }, + "args": [], + "destination": { + "local": 4, + "projection": [] + }, + "target": 4, + "unwind": "Continue" + } + }, + "span": 97 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 98 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 99, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 91, + "mutability": "Not" + }, + { + "ty": 1, + "span": 93, + "mutability": "Not" + }, + { + "ty": 1, + "span": 95, + "mutability": "Not" + }, + { + "ty": 1, + "span": 97, + "mutability": "Not" + } + ], + "arg_count": 0, + "var_debug_info": [], + "spread_arg": null, + "span": 100 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17h32322c5090c6cda5E", + "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$17hf85973269d63cf9dE", + "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_backtrace17hdef7e1fa9f62bfa1E", + "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": "_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h599eaaadf84c2db0E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<&i32 as std::fmt::Debug>::fmt", + "id": 3, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 1, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 45 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 43, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 21, + "id": 6 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 44 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 46 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 47, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 48, + "mutability": "Not" + }, + { + "ty": 24, + "span": 49, + "mutability": "Not" + }, + { + "ty": 25, + "span": 48, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 48, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 49, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + } + ], + "spread_arg": null, + "span": 50 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i32$GT$3fmt17h349a8b3b9d886ac3E", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::fmt::num::::fmt", + "id": 4, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 3 + }, + "span": 52 + }, + { + "kind": { + "StorageLive": 4 + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 26 + ] + } + ] + } + } + } + ] + }, + "span": 53 + }, + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 4, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 16, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 26, + "id": 7 + } + } + } + ] + } + ] + }, + "span": 52 + }, + { + "kind": { + "StorageDead": 4 + }, + "span": 54 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 3, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 2 + ] + ], + "otherwise": 1 + } + } + }, + "span": 51 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 27, + "id": 8 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 6, + "unwind": "Continue" + } + }, + "span": 56 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 3 + }, + "span": 51 + }, + { + "kind": { + "StorageLive": 5 + }, + "span": 58 + }, + { + "kind": { + "StorageLive": 6 + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 2, + "projection": [ + "Deref", + { + "Field": [ + 0, + 26 + ] + } + ] + } + } + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Move": { + "local": 6, + "projection": [] + } + }, + { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 32, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 26, + "id": 9 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "StorageDead": 6 + }, + "span": 60 + } + ], + "terminator": { + "kind": { + "SwitchInt": { + "discr": { + "Move": { + "local": 5, + "projection": [] + } + }, + "targets": { + "branches": [ + [ + 0, + 4 + ] + ], + "otherwise": 3 + } + } + }, + "span": 57 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 61, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 28, + "id": 10 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 62 + } + }, + { + "statements": [ + { + "kind": { + "StorageDead": 5 + }, + "span": 57 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 63, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 29, + "id": 11 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 5, + "unwind": "Continue" + } + }, + "span": 64 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Goto": { + "target": 6 + } + }, + "span": 65 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 66 + } + } + ], + "locals": [ + { + "ty": 22, + "span": 67, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 68, + "mutability": "Not" + }, + { + "ty": 24, + "span": 69, + "mutability": "Not" + }, + { + "ty": 26, + "span": 52, + "mutability": "Mut" + }, + { + "ty": 26, + "span": 53, + "mutability": "Mut" + }, + { + "ty": 26, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 26, + "span": 59, + "mutability": "Mut" + } + ], + "arg_count": 2, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 68, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "f", + "source_info": { + "span": 69, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "self", + "source_info": { + "span": 70, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "self", + "source_info": { + "span": 71, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 1 + } + ], + "spread_arg": null, + "span": 72 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17hc0b096f6edd29006E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 5, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 73, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 30, + "id": 12 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [ + "Deref" + ] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h42df40f4886b05f7E", + "mono_item_kind": { + "MonoItemFn": { + "name": ">::call_once", + "id": 5, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": { + "Call": { + "func": { + "Move": { + "local": 1, + "projection": [] + } + }, + "args": [], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 7, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ops8function6FnOnce9call_once17h880dba0474f28974E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<{closure@std::rt::lang_start<()>::{closure#0}} as std::ops::FnOnce<()>>::call_once", + "id": 5, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + { + "Mut": { + "kind": "Default" + } + }, + { + "local": 1, + "projection": [] + } + ] + } + ] + }, + "span": 73 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 73, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 32, + "id": 13 + } + } + }, + "args": [ + { + "Move": { + "local": 3, + "projection": [] + } + }, + { + "Move": { + "local": 2, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": 1, + "unwind": { + "Cleanup": 3 + } + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 2, + "unwind": "Continue" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": { + "Drop": { + "place": { + "local": 1, + "projection": [] + }, + "target": 4, + "unwind": "Terminate" + } + }, + "span": 73 + } + }, + { + "statements": [], + "terminator": { + "kind": "Resume", + "span": 73 + } + } + ], + "locals": [ + { + "ty": 16, + "span": 73, + "mutability": "Mut" + }, + { + "ty": 12, + "span": 73, + "mutability": "Not" + }, + { + "ty": 1, + "span": 73, + "mutability": "Not" + }, + { + "ty": 33, + "span": 73, + "mutability": "Not" + } + ], + "arg_count": 2, + "var_debug_info": [], + "spread_arg": 2, + "span": 73 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr28drop_in_place$LT$$RF$i32$GT$17hc3dafcd27715331fE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<&i32>", + "id": 6, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 34, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h52b7dcc20d333d6bE", + "mono_item_kind": { + "MonoItemFn": { + "name": "std::ptr::drop_in_place::<{closure@std::rt::lang_start<()>::{closure#0}}>", + "id": 6, + "body": { + "blocks": [ + { + "statements": [], + "terminator": { + "kind": "Return", + "span": 74 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 74, + "mutability": "Mut" + }, + { + "ty": 31, + "span": 74, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [], + "spread_arg": null, + "span": 74 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN4core9panicking13assert_failed17h2897bbde3c223800E", + "mono_item_kind": { + "MonoItemFn": { + "name": "core::panicking::assert_failed::", + "id": 7, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "StorageLive": 5 + }, + "span": 77 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 2, + "projection": [] + } + ] + } + ] + }, + "span": 77 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 6, + "projection": [] + } + }, + 36 + ] + } + ] + }, + "span": 77 + }, + { + "kind": { + "StorageLive": 7 + }, + "span": 78 + }, + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 3, + "projection": [] + } + ] + } + ] + }, + "span": 78 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "Cast": [ + { + "PointerCoercion": "Unsize" + }, + { + "Copy": { + "local": 8, + "projection": [] + } + }, + 36 + ] + } + ] + }, + "span": 78 + } + ], + "terminator": { + "kind": { + "Call": { + "func": { + "Constant": { + "span": 75, + "user_ty": null, + "const_": { + "kind": "ZeroSized", + "ty": 35, + "id": 14 + } + } + }, + "args": [ + { + "Move": { + "local": 1, + "projection": [] + } + }, + { + "Move": { + "local": 5, + "projection": [] + } + }, + { + "Move": { + "local": 7, + "projection": [] + } + }, + { + "Move": { + "local": 4, + "projection": [] + } + } + ], + "destination": { + "local": 0, + "projection": [] + }, + "target": null, + "unwind": "Continue" + } + }, + "span": 76 + } + } + ], + "locals": [ + { + "ty": 37, + "span": 79, + "mutability": "Mut" + }, + { + "ty": 38, + "span": 80, + "mutability": "Not" + }, + { + "ty": 25, + "span": 81, + "mutability": "Not" + }, + { + "ty": 25, + "span": 82, + "mutability": "Not" + }, + { + "ty": 39, + "span": 83, + "mutability": "Not" + }, + { + "ty": 36, + "span": 77, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 77, + "mutability": "Not" + }, + { + "ty": 36, + "span": 78, + "mutability": "Mut" + }, + { + "ty": 23, + "span": 78, + "mutability": "Not" + } + ], + "arg_count": 4, + "var_debug_info": [ + { + "name": "kind", + "source_info": { + "span": 80, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": 1 + }, + { + "name": "left", + "source_info": { + "span": 81, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": 2 + }, + { + "name": "right", + "source_info": { + "span": 82, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 3, + "projection": [] + } + }, + "argument_index": 3 + }, + { + "name": "args", + "source_info": { + "span": 83, + "scope": 0 + }, + "composite": null, + "value": { + "Place": { + "local": 4, + "projection": [] + } + }, + "argument_index": 4 + } + ], + "spread_arg": null, + "span": 84 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17h53e1e5f50ff28559E", + "mono_item_kind": { + "MonoItemFn": { + "name": "<() as std::process::Termination>::report", + "id": 8, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 0, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 86, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 1, + "mutability": "Mut" + } + }, + "ty": 17, + "id": 15 + } + } + } + } + ] + }, + "span": 86 + } + ], + "terminator": { + "kind": "Return", + "span": 85 + } + } + ], + "locals": [ + { + "ty": 17, + "span": 87, + "mutability": "Mut" + }, + { + "ty": 1, + "span": 88, + "mutability": "Not" + } + ], + "arg_count": 1, + "var_debug_info": [ + { + "name": "self", + "source_info": { + "span": 88, + "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": 89 + } + } + }, + "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": 81, + "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": 82, + "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": 51, + "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": 62, + "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": 60, + "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, + { + "EnumType": { + "name": "std::result::Result<(), std::fmt::Error>", + "adt_def": 51, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 1 + ], + [ + 77 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 8 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 23, + { + "RefType": { + "pointee_type": 25, + "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 + } + } + } + } + ], + [ + 24, + { + "RefType": { + "pointee_type": 73, + "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, + { + "RefType": { + "pointee_type": 16, + "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 + } + } + } + } + ], + [ + 26, + { + "PrimitiveType": { + "Uint": "U32" + } + } + ], + [ + 31, + { + "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 + } + } + } + } + ], + [ + 33, + { + "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 + } + } + } + } + ], + [ + 34, + { + "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 + } + } + } + } + ], + [ + 36, + { + "RefType": { + "pointee_type": 51, + "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 + } + } + } + } + ], + [ + 37, + "VoidType" + ], + [ + 38, + { + "EnumType": { + "name": "core::panicking::AssertKind", + "adt_def": 11, + "discriminants": [ + 0, + 1, + 2 + ], + "fields": [ + [], + [], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 39, + { + "EnumType": { + "name": "std::option::Option>", + "adt_def": 12, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 46 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 1, + "niche_variants": { + "start": 0, + "end": 0 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + ] + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + } + } + ], + [ + 44, + { + "PrimitiveType": { + "Uint": "Usize" + } + } + ], + [ + 46, + { + "StructType": { + "name": "std::fmt::Arguments<'_>", + "adt_def": 19, + "fields": [ + 53, + 54, + 55 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 256 + }, + { + "num_bits": 128 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 384 + } + } + } + } + ], + [ + 47, + { + "ArrayType": { + "elem_type": 16, + "size": { + "kind": { + "Value": [ + 44, + { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 0 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 5 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 160 + } + } + } + } + ], + [ + 48, + { + "PtrType": { + "pointee_type": 16, + "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 + } + } + } + } + ], + [ + 49, + { + "PrimitiveType": "Bool" + } + ], + [ + 50, + { + "TupleType": { + "types": [ + 25, + 25 + ], + "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 + } + } + } + } + ], + [ + 52, + { + "RefType": { + "pointee_type": 79, + "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 + } + } + } + } + ], + [ + 53, + { + "RefType": { + "pointee_type": 56, + "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 + } + } + } + } + ], + [ + 54, + { + "EnumType": { + "name": "std::option::Option<&[core::fmt::rt::Placeholder]>", + "adt_def": 12, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 59 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 1, + "niche_variants": { + "start": 0, + "end": 0 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "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 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 55, + { + "RefType": { + "pointee_type": 65, + "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 + } + } + } + } + ], + [ + 56, + { + "ArrayType": { + "elem_type": 57, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 128 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 57, + { + "RefType": { + "pointee_type": 58, + "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 + } + } + } + } + ], + [ + 58, + { + "PrimitiveType": "Str" + } + ], + [ + 59, + { + "RefType": { + "pointee_type": 60, + "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 + } + } + } + } + ], + [ + 60, + { + "ArrayType": { + "elem_type": 61, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 448 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 61, + { + "StructType": { + "name": "core::fmt::rt::Placeholder", + "adt_def": 23, + "fields": [ + 44, + 62, + 63, + 26, + 64, + 64 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 256 + }, + { + "num_bits": 320 + }, + { + "num_bits": 384 + }, + { + "num_bits": 352 + }, + { + "num_bits": 0 + }, + { + "num_bits": 128 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 448 + } + } + } + } + ], + [ + 62, + { + "PrimitiveType": "Char" + } + ], + [ + 63, + { + "EnumType": { + "name": "core::fmt::rt::Alignment", + "adt_def": 30, + "discriminants": [ + 0, + 1, + 2, + 3 + ], + "fields": [ + [], + [], + [], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 3 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 3 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + ] + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Int": { + "length": "I8", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 3 + } + } + } + }, + "abi_align": 1, + "size": { + "num_bits": 8 + } + } + } + } + ], + [ + 64, + { + "EnumType": { + "name": "core::fmt::rt::Count", + "adt_def": 31, + "discriminants": [ + 0, + 1, + 2 + ], + "fields": [ + [ + 44 + ], + [ + 44 + ], + [] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 2 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 64 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 2 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 65, + { + "ArrayType": { + "elem_type": 66, + "size": null, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 128 + }, + "count": 0 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": false + } + }, + "abi_align": 8, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 66, + { + "StructType": { + "name": "core::fmt::rt::Argument<'_>", + "adt_def": 34, + "fields": [ + 67 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 67, + { + "EnumType": { + "name": "core::fmt::rt::ArgumentType<'_>", + "adt_def": 36, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 68, + 69, + 70 + ], + [ + 44 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 0 + } + } + }, + "tag_encoding": { + "Niche": { + "untagged_variant": 0, + "niche_variants": { + "start": 1, + "end": 1 + }, + "niche_start": 0 + } + }, + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + }, + { + "num_bits": 64 + }, + { + "num_bits": 128 + } + ] + } + }, + "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 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + ] + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 68, + { + "StructType": { + "name": "std::ptr::NonNull<()>", + "adt_def": 41, + "fields": [ + 71 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Scalar": { + "Initialized": { + "value": { + "Pointer": 0 + }, + "valid_range": { + "start": 1, + "end": 18446744073709551615 + } + } + } + }, + "abi_align": 8, + "size": { + "num_bits": 64 + } + } + } + } + ], + [ + 70, + { + "StructType": { + "name": "std::marker::PhantomData<&()>", + "adt_def": 55, + "fields": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 71, + { + "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 + } + } + } + } + ], + [ + 73, + { + "StructType": { + "name": "std::fmt::Formatter<'_>", + "adt_def": 43, + "fields": [ + 26, + 62, + 63, + 74, + 74, + 75 + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 416 + }, + { + "num_bits": 384 + }, + { + "num_bits": 448 + }, + { + "num_bits": 0 + }, + { + "num_bits": 128 + }, + { + "num_bits": 256 + } + ] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 8, + "size": { + "num_bits": 512 + } + } + } + } + ], + [ + 74, + { + "EnumType": { + "name": "std::option::Option", + "adt_def": 12, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [], + [ + 44 + ] + ], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 0 + } + ] + } + }, + "variants": { + "Multiple": { + "tag": { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + "tag_encoding": "Direct", + "tag_field": 0, + "variants": [ + { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 64 + } + }, + { + "fields": { + "Arbitrary": { + "offsets": [ + { + "num_bits": 64 + } + ] + } + }, + "variants": { + "Single": { + "index": 1 + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + ] + } + }, + "abi": { + "ScalarPair": [ + { + "Initialized": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + }, + "valid_range": { + "start": 0, + "end": 1 + } + } + }, + { + "Union": { + "value": { + "Int": { + "length": "I64", + "signed": false + } + } + } + } + ] + }, + "abi_align": 8, + "size": { + "num_bits": 128 + } + } + } + } + ], + [ + 75, + { + "RefType": { + "pointee_type": 76, + "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 + } + } + } + } + ], + [ + 77, + { + "StructType": { + "name": "std::fmt::Error", + "adt_def": 54, + "fields": [], + "layout": { + "fields": { + "Arbitrary": { + "offsets": [] + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 1, + "size": { + "num_bits": 0 + } + } + } + } + ], + [ + 78, + { + "RefType": { + "pointee_type": 1, + "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 + } + } + } + } + ], + [ + 79, + { + "StructType": { + "name": "std::panic::Location<'_>", + "adt_def": 56, + "fields": [ + 57, + 26, + 26 + ], + "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 + } + } + } + } + ], + [ + 82, + { + "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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 62, + 2393, + 70 + ] + ], + [ + 44, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 62, + 2393, + 82 + ] + ], + [ + 45, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 71, + 2393, + 78 + ] + ], + [ + 46, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 84, + 2393, + 84 + ] + ], + [ + 48, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 20, + 2393, + 25 + ] + ], + [ + 49, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 27, + 2393, + 28 + ] + ], + [ + 50, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 2393, + 13, + 2393, + 84 + ] + ], + [ + 51, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 181, + 24, + 181, + 43 + ] + ], + [ + 52, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 9, + 1937, + 59 + ] + ], + [ + 53, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 9, + 1937, + 19 + ] + ], + [ + 54, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1937, + 58, + 1937, + 59 + ] + ], + [ + 55, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 182, + 25, + 182, + 43 + ] + ], + [ + 56, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 182, + 25, + 182, + 52 + ] + ], + [ + 57, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 183, + 31, + 183, + 50 + ] + ], + [ + 58, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 9, + 1941, + 59 + ] + ], + [ + 59, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 9, + 1941, + 19 + ] + ], + [ + 60, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1941, + 58, + 1941, + 59 + ] + ], + [ + 61, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 184, + 25, + 184, + 43 + ] + ], + [ + 62, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 184, + 25, + 184, + 52 + ] + ], + [ + 63, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 186, + 25, + 186, + 42 + ] + ], + [ + 64, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 186, + 25, + 186, + 51 + ] + ], + [ + 65, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 181, + 21, + 187, + 22 + ] + ], + [ + 66, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 188, + 18, + 188, + 18 + ] + ], + [ + 68, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 24, + 180, + 29 + ] + ], + [ + 69, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 31, + 180, + 32 + ] + ], + [ + 70, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1936, + 24, + 1936, + 29 + ] + ], + [ + 71, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/mod.rs", + 1940, + 24, + 1940, + 29 + ] + ], + [ + 72, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/fmt/num.rs", + 180, + 17, + 188, + 18 + ] + ], + [ + 73, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs", + 250, + 5, + 250, + 71 + ] + ], + [ + 74, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ptr/mod.rs", + 521, + 1, + 521, + 56 + ] + ], + [ + 75, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 5, + 373, + 24 + ] + ], + [ + 76, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 5, + 373, + 51 + ] + ], + [ + 77, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 31, + 373, + 36 + ] + ], + [ + 78, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 373, + 38, + 373, + 44 + ] + ], + [ + 80, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 364, + 5, + 364, + 9 + ] + ], + [ + 81, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 365, + 5, + 365, + 9 + ] + ], + [ + 82, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 366, + 5, + 366, + 10 + ] + ], + [ + 83, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 367, + 5, + 367, + 9 + ] + ], + [ + 84, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/panicking.rs", + 363, + 1, + 374, + 2 + ] + ], + [ + 85, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 86, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 88, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 89, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 90, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 5, + 5, + 5, + 21 + ] + ], + [ + 91, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 5, + 5, + 5, + 23 + ] + ], + [ + 92, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 6, + 5, + 6, + 25 + ] + ], + [ + 93, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 6, + 5, + 6, + 27 + ] + ], + [ + 94, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 7, + 5, + 7, + 23 + ] + ], + [ + 95, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 7, + 5, + 7, + 25 + ] + ], + [ + 96, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 8, + 5, + 8, + 25 + ] + ], + [ + 97, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 8, + 5, + 8, + 27 + ] + ], + [ + 98, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 9, + 2, + 9, + 2 + ] + ], + [ + 100, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 4, + 1, + 9, + 2 + ] + ], + [ + 101, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 14, + 16, + 14, + 22 + ] + ], + [ + 102, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 16, + 13, + 20 + ] + ], + [ + 103, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 22, + 13, + 23 + ] + ], + [ + 104, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 25, + 13, + 26 + ] + ], + [ + 105, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 28, + 13, + 29 + ] + ], + [ + 106, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 31, + 13, + 32 + ] + ], + [ + 107, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 15, + 13, + 33 + ] + ], + [ + 108, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 14, + 20, + 14, + 21 + ] + ], + [ + 109, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 110, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 14, + 15, + 14, + 22 + ] + ], + [ + 111, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 17, + 30, + 17, + 36 + ] + ], + [ + 112, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 17, + 18, + 17, + 37 + ] + ], + [ + 113, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 114, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 115, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 116, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 117, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 118, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 119, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 120, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 20, + 2, + 20, + 2 + ] + ], + [ + 121, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 122, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 123, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 124, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 126, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 13, + 9, + 13, + 12 + ] + ], + [ + 127, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 14, + 9, + 14, + 12 + ] + ], + [ + 128, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 17, + 13, + 17, + 15 + ] + ], + [ + 129, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 130, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 12, + 1, + 20, + 2 + ] + ], + [ + 131, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 25, + 16, + 25, + 22 + ] + ], + [ + 132, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 16, + 24, + 20 + ] + ], + [ + 133, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 22, + 24, + 23 + ] + ], + [ + 134, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 25, + 24, + 26 + ] + ], + [ + 135, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 28, + 24, + 29 + ] + ], + [ + 136, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 31, + 24, + 32 + ] + ], + [ + 137, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 15, + 24, + 33 + ] + ], + [ + 138, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 25, + 20, + 25, + 21 + ] + ], + [ + 139, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 140, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 25, + 15, + 25, + 22 + ] + ], + [ + 141, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 29, + 30, + 29, + 36 + ] + ], + [ + 142, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 29, + 18, + 29, + 37 + ] + ], + [ + 143, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 144, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 145, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 146, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 147, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 148, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 149, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 150, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 151, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 33, + 30, + 33, + 36 + ] + ], + [ + 152, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 33, + 18, + 33, + 37 + ] + ], + [ + 153, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 154, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 155, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 156, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 157, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 158, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 159, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 160, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 161, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 162, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 163, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 164, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 36, + 2, + 36, + 2 + ] + ], + [ + 165, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 166, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 167, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 168, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 170, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 24, + 9, + 24, + 12 + ] + ], + [ + 171, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 25, + 9, + 25, + 12 + ] + ], + [ + 172, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 29, + 13, + 29, + 15 + ] + ], + [ + 173, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 174, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 33, + 13, + 33, + 15 + ] + ], + [ + 175, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 176, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 23, + 1, + 36, + 2 + ] + ], + [ + 177, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 41, + 16, + 41, + 22 + ] + ], + [ + 178, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 16, + 40, + 20 + ] + ], + [ + 179, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 22, + 40, + 23 + ] + ], + [ + 180, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 25, + 40, + 26 + ] + ], + [ + 181, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 28, + 40, + 29 + ] + ], + [ + 182, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 31, + 40, + 32 + ] + ], + [ + 183, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 15, + 40, + 33 + ] + ], + [ + 184, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 41, + 20, + 41, + 21 + ] + ], + [ + 185, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 186, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 41, + 15, + 41, + 22 + ] + ], + [ + 187, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 44, + 30, + 44, + 36 + ] + ], + [ + 188, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 44, + 18, + 44, + 37 + ] + ], + [ + 189, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 190, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 191, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 192, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 193, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 194, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 195, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 196, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 47, + 2, + 47, + 2 + ] + ], + [ + 197, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 198, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 199, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 200, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 202, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 40, + 9, + 40, + 12 + ] + ], + [ + 203, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 41, + 9, + 41, + 12 + ] + ], + [ + 204, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 44, + 13, + 44, + 15 + ] + ], + [ + 205, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 206, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 39, + 1, + 47, + 2 + ] + ], + [ + 207, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 52, + 16, + 52, + 22 + ] + ], + [ + 208, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 16, + 51, + 21 + ] + ], + [ + 209, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 23, + 51, + 25 + ] + ], + [ + 210, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 27, + 51, + 29 + ] + ], + [ + 211, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 31, + 51, + 33 + ] + ], + [ + 212, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 35, + 51, + 37 + ] + ], + [ + 213, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 15, + 51, + 38 + ] + ], + [ + 214, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 52, + 20, + 52, + 21 + ] + ], + [ + 215, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 216, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 52, + 15, + 52, + 22 + ] + ], + [ + 217, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 56, + 34, + 56, + 41 + ] + ], + [ + 218, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 56, + 22, + 56, + 42 + ] + ], + [ + 219, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 220, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 221, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 222, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 223, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 224, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 225, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 226, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 227, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 60, + 35, + 60, + 42 + ] + ], + [ + 228, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 60, + 23, + 60, + 43 + ] + ], + [ + 229, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 230, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 231, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 232, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 233, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 234, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 235, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 236, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 237, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 238, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 239, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 240, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 21, + 46, + 46 + ] + ], + [ + 241, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 64, + 34, + 64, + 40 + ] + ], + [ + 242, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 64, + 22, + 64, + 41 + ] + ], + [ + 243, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 16, + 44, + 22 + ] + ], + [ + 244, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 24, + 44, + 31 + ] + ], + [ + 245, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 44, + 15, + 44, + 32 + ] + ], + [ + 246, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 14, + 45, + 22 + ] + ], + [ + 247, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 45, + 24, + 45, + 33 + ] + ], + [ + 248, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 22, + 46, + 31 + ] + ], + [ + 249, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 46, + 35, + 46, + 45 + ] + ], + [ + 250, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 251, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 252, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 253, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 254, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 67, + 2, + 67, + 2 + ] + ], + [ + 255, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 53 + ] + ], + [ + 256, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 21, + 51, + 114 + ] + ], + [ + 257, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 32, + 47, + 65 + ] + ], + [ + 258, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 51, + 85, + 51, + 113 + ] + ], + [ + 260, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 51, + 9, + 51, + 12 + ] + ], + [ + 261, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 52, + 9, + 52, + 12 + ] + ], + [ + 262, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 56, + 13, + 56, + 19 + ] + ], + [ + 263, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 264, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 60, + 13, + 60, + 20 + ] + ], + [ + 265, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 266, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 64, + 13, + 64, + 19 + ] + ], + [ + 267, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/macros/mod.rs", + 47, + 25, + 47, + 29 + ] + ], + [ + 268, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs", + 50, + 1, + 67, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-basic.state b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-basic.state new file mode 100644 index 000000000..c88a83be2 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-basic.state @@ -0,0 +1,65 @@ + + + #execStmts ( statement (... kind: statementKindAssign (... place: place (... local: local ( 11 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 8 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 25 ) ) .ProjectionElems ) ) ) ) , span: span ( 116 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 12 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 8 ) , projection: projectionElemField ( fieldIdx ( 1 ) , ty ( 25 ) ) .ProjectionElems ) ) ) ) , span: span ( 117 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 14 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 11 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 118 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 15 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 12 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 119 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 13 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandMove ( place (... local: local ( 14 ) , projection: .ProjectionElems ) ) , operandMove ( place (... local: local ( 15 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 109 ) ) .Statements ) ~> #execTerminator ( terminator (... kind: terminatorKindSwitchInt (... discr: operandMove ( place (... local: local ( 13 ) , projection: .ProjectionElems ) ) , targets: switchTargets (... branches: branch ( 0 , basicBlockIdx ( 3 ) ) .Branches , otherwise: basicBlockIdx ( 2 ) ) ) , span: span ( 109 ) ) ) ~> .K + + + noReturn + + + ty ( 40 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 1 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindArray ( ty ( 16 ) ) , operandConstant ( constOperand (... span: span ( 102 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 20 ) ) ) ) operandConstant ( constOperand (... span: span ( 103 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x02\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 21 ) ) ) ) operandConstant ( constOperand (... span: span ( 104 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x03\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 22 ) ) ) ) operandConstant ( constOperand (... span: span ( 105 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x04\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 23 ) ) ) ) operandConstant ( constOperand (... span: span ( 106 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 24 ) ) ) ) .Operands ) ) , span: span ( 107 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 108 ) , 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 ( 44 ) , id: mirConstId ( 25 ) ) ) ) ) ) , span: span ( 108 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 44 ) , id: mirConstId ( 26 ) ) ) ) ) ) , span: span ( 101 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpLt , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 101 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageBoundsCheck (... len: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , index: operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionContinue ) , span: span ( 101 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 1 ) , projection: projectionElemIndex ( local ( 4 ) ) .ProjectionElems ) ) ) , span: span ( 110 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 3 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 110 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 111 ) , 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 ( 6 ) , id: mirConstId ( 27 ) ) ) ) ) ) , span: span ( 112 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 7 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 113 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 10 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 114 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\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 ( 25 ) , id: mirConstId ( 28 ) ) ) ) ) ) , span: span ( 114 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindTuple , operandMove ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) operandMove ( place (... local: local ( 10 ) , projection: .ProjectionElems ) ) .Operands ) ) , span: span ( 115 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 11 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 8 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 25 ) ) .ProjectionElems ) ) ) ) , span: span ( 116 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 12 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 8 ) , projection: projectionElemField ( fieldIdx ( 1 ) , ty ( 25 ) ) .ProjectionElems ) ) ) ) , span: span ( 117 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 14 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 11 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 118 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 15 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 12 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 119 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 13 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandMove ( place (... local: local ( 14 ) , projection: .ProjectionElems ) ) , operandMove ( place (... local: local ( 15 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 109 ) ) .Statements , terminator: terminator (... kind: terminatorKindSwitchInt (... discr: operandMove ( place (... local: local ( 13 ) , projection: .ProjectionElems ) ) , targets: switchTargets (... branches: branch ( 0 , basicBlockIdx ( 3 ) ) .Branches , otherwise: basicBlockIdx ( 2 ) ) ) , span: span ( 109 ) ) ) ) + ListItem ( basicBlock (... statements: .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 120 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 16 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindAdt ( adtDef ( 11 ) , variantIdx ( 0 ) , .GenericArgs , noUserTypeAnnotationIndex , noFieldIdx ) , .Operands ) ) , span: span ( 123 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 18 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindAdt ( adtDef ( 12 ) , variantIdx ( 0 ) , genericArgKindType ( ty ( 46 ) ) .GenericArgs , noUserTypeAnnotationIndex , noFieldIdx ) , .Operands ) ) , span: span ( 124 ) ) .Statements , terminator: terminator (... kind: terminatorKindCall (... func: operandConstant ( constOperand (... span: span ( 121 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindZeroSized , ty: ty ( 45 ) , id: mirConstId ( 29 ) ) ) ) , args: operandMove ( place (... local: local ( 16 ) , projection: .ProjectionElems ) ) operandCopy ( place (... local: local ( 11 ) , projection: .ProjectionElems ) ) operandCopy ( place (... local: local ( 12 ) , projection: .ProjectionElems ) ) operandMove ( place (... local: local ( 18 ) , projection: .ProjectionElems ) ) .Operands , destination: place (... local: local ( 17 ) , projection: .ProjectionElems ) , target: noBasicBlockIdx , unwind: unwindActionContinue ) , span: span ( 122 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 1 ) , projection: .ProjectionElems ) + + + someBasicBlockIdx ( basicBlockIdx ( 1 ) ) + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Range ( ListItem ( Integer ( 1 , 32 , true ) ) + ListItem ( Integer ( 2 , 32 , true ) ) + ListItem ( Integer ( 3 , 32 , true ) ) + ListItem ( Integer ( 4 , 32 , true ) ) + ListItem ( Integer ( 5 , 32 , true ) ) ) , ty ( 47 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) , ty ( 48 ) , mutabilityNot ) ) + ListItem ( typedValue ( Reference ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) , ty ( 25 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 0 , 64 , false ) , ty ( 44 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 5 , 64 , false ) , ty ( 44 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 49 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) , ty ( 48 ) , mutabilityNot ) ) + ListItem ( typedValue ( Aggregate ( variantIdx ( 0 ) , ListItem ( Reference ( 0 , place (... local: local ( 1 ) , projection: projectionElemConstantIndex (... offset: 0 , minLength: 0 , fromEnd: false ) .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) + ListItem ( AllocRef ( allocId ( 0 ) , .ProjectionElems , metadata ( noMetadataSize , 0 , noMetadataSize ) ) ) ) , ty ( 50 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) + ListItem ( typedValue ( Moved , ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 49 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 16 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 16 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 38 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 37 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 39 ) , mutabilityMut ) ) + + + + ListItem ( StackFrame ( ty ( -1 ) , place (... local: local ( 0 ) , projection: .ProjectionElems ) , noBasicBlockIdx , unwindActionContinue , ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 1 ) , mutabilityNot ) ) ) ) + 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/ptr-offset-bounds-fail.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-bounds-fail.smir.json new file mode 100644 index 000000000..9be6e2e64 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-bounds-fail.smir.json @@ -0,0 +1,3477 @@ +{ + "name": "ptr_offset_bounds_fail", + "crate_id": 14129035602699992591, + "allocs": [], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17ha7145c347263c246E" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17hedc5155a5a214917E" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h02d5a0d8ea77236dE" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h22d8341955afa04cE" + } + ], + [ + 23, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17h9bba1ff984d20a59E" + } + ], + [ + 31, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN22ptr_offset_bounds_fail4main17hfacbfdc60726baebE", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 6, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 51, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 9 + } + } + }, + { + "Constant": { + "span": 52, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 10 + } + } + }, + { + "Constant": { + "span": 53, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 11 + } + } + }, + { + "Constant": { + "span": 54, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 12 + } + } + }, + { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 13 + } + } + } + ] + ] + } + ] + }, + "span": 56 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 57, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 14 + } + } + } + } + ] + }, + "span": 57 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 15 + } + } + } + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 50 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 50 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 60, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 6, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 16 + } + } + } + ] + } + ] + }, + "span": 61 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 7, + "projection": [] + } + }, + 26 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Cast": [ + "Transmute", + { + "Copy": { + "local": 9, + "projection": [] + } + }, + 25 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "NullaryOp": [ + "AlignOf", + 16 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "BinaryOp": [ + "Sub", + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Constant": { + "span": 58, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 17 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Copy": { + "local": 10, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Copy": { + "local": 13, + "projection": [] + } + }, + { + "Constant": { + "span": 58, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 14 + } + } + } + ] + } + ] + }, + "span": 58 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Copy": { + "local": 14, + "projection": [] + } + }, + "expected": true, + "msg": { + "MisalignedPointerDereference": { + "required": { + "Copy": { + "local": 11, + "projection": [] + } + }, + "found": { + "Copy": { + "local": 10, + "projection": [] + } + } + } + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 58 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 7, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 58 + } + ], + "terminator": { + "kind": "Return", + "span": 62 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 63, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 64, + "mutability": "Not" + }, + { + "ty": 28, + "span": 65, + "mutability": "Not" + }, + { + "ty": 29, + "span": 59, + "mutability": "Not" + }, + { + "ty": 25, + "span": 57, + "mutability": "Not" + }, + { + "ty": 25, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 66, + "mutability": "Not" + }, + { + "ty": 16, + "span": 67, + "mutability": "Not" + }, + { + "ty": 26, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 58, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 64, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 65, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_oob", + "source_info": { + "span": 66, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "_x", + "source_info": { + "span": 67, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 8, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 68 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17hc42b7b0b1a9969cbE", + "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$17h9bba1ff984d20a59E", + "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_backtrace17ha7145c347263c246E", + "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$17h1b87589008c48575E", + "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_once17h02d5a0d8ea77236dE", + "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_once17h22d8341955afa04cE", + "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$17hc2c61d4cb927de71E", + "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$6report17hedc5155a5a214917E", + "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 + } + } + } + } + ], + [ + 5, + { + "RefType": { + "pointee_type": 32, + "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": 33, + "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": 19, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 6 + ], + [ + 34 + ] + ], + "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": 11, + "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": 9, + "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": { + "Uint": "Usize" + } + } + ], + [ + 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, + { + "ArrayType": { + "elem_type": 16, + "size": { + "kind": { + "Value": [ + 25, + { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 0 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 5 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 160 + } + } + } + } + ], + [ + 28, + { + "PtrType": { + "pointee_type": 16, + "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, + { + "RefType": { + "pointee_type": 16, + "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, + { + "PrimitiveType": "Bool" + } + ], + [ + 33, + { + "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 + } + } + } + } + ], + [ + 34, + "VoidType" + ] + ], + "spans": [ + [ + 0, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 46, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 48, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 49, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 50, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 7, + 16, + 7, + 22 + ] + ], + [ + 51, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 16, + 6, + 20 + ] + ], + [ + 52, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 22, + 6, + 23 + ] + ], + [ + 53, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 25, + 6, + 26 + ] + ], + [ + 54, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 28, + 6, + 29 + ] + ], + [ + 55, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 31, + 6, + 32 + ] + ], + [ + 56, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 15, + 6, + 33 + ] + ], + [ + 57, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 7, + 20, + 7, + 21 + ] + ], + [ + 58, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 12, + 18, + 12, + 24 + ] + ], + [ + 59, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 7, + 15, + 7, + 22 + ] + ], + [ + 60, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 11, + 33, + 11, + 39 + ] + ], + [ + 61, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 11, + 21, + 11, + 40 + ] + ], + [ + 62, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 14, + 2, + 14, + 2 + ] + ], + [ + 64, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 6, + 9, + 6, + 12 + ] + ], + [ + 65, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 7, + 9, + 7, + 12 + ] + ], + [ + 66, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 11, + 13, + 11, + 18 + ] + ], + [ + 67, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 12, + 13, + 12, + 15 + ] + ], + [ + 68, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs", + 5, + 1, + 14, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-bounds-fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-bounds-fail.state new file mode 100644 index 000000000..98ccee4e1 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-bounds-fail.state @@ -0,0 +1,54 @@ + + + #execStmt ( statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpLt , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) ) ~> #execStmts ( .Statements ) ~> #execTerminator ( terminator (... kind: assert (... cond: operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageBoundsCheck (... len: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , index: operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionContinue ) , span: span ( 50 ) ) ) ~> .K + + + noReturn + + + ty ( -1 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 1 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindArray ( ty ( 16 ) ) , operandConstant ( constOperand (... span: span ( 51 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 9 ) ) ) ) operandConstant ( constOperand (... span: span ( 52 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x02\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 10 ) ) ) ) operandConstant ( constOperand (... span: span ( 53 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x03\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 11 ) ) ) ) operandConstant ( constOperand (... span: span ( 54 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x04\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 12 ) ) ) ) operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 13 ) ) ) ) .Operands ) ) , span: span ( 56 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 57 ) , 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 ( 25 ) , id: mirConstId ( 14 ) ) ) ) ) ) , span: span ( 57 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 25 ) , id: mirConstId ( 15 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpLt , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageBoundsCheck (... len: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , index: operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionContinue ) , span: span ( 50 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 1 ) , projection: projectionElemIndex ( local ( 4 ) ) .ProjectionElems ) ) ) , span: span ( 59 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 3 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 59 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 60 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x06\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 6 ) , id: mirConstId ( 16 ) ) ) ) ) ) , span: span ( 61 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 10 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 11 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 16 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 12 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 11 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 58 ) , 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 ( 25 ) , id: mirConstId ( 17 ) ) ) ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 13 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 10 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 12 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 14 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 13 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 58 ) , 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 ( 25 ) , id: mirConstId ( 14 ) ) ) ) ) ) , span: span ( 58 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 14 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 11 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 10 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 2 ) , unwind: unwindActionUnreachable ) , span: span ( 58 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 7 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 58 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 62 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 0 ) , projection: .ProjectionElems ) + + + noBasicBlockIdx + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Range ( ListItem ( Integer ( 1 , 32 , true ) ) + ListItem ( Integer ( 2 , 32 , true ) ) + ListItem ( Integer ( 3 , 32 , true ) ) + ListItem ( Integer ( 4 , 32 , true ) ) + ListItem ( Integer ( 5 , 32 , true ) ) ) , ty ( 27 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 0 , 64 , false ) , ty ( 25 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 5 , 64 , false ) , ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 30 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 16 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 26 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 30 ) , 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/ptr-offset-negative-fail.smir.json b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-negative-fail.smir.json new file mode 100644 index 000000000..9fa63b288 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-negative-fail.smir.json @@ -0,0 +1,3477 @@ +{ + "name": "ptr_offset_negative_fail", + "crate_id": 18406250229207100876, + "allocs": [], + "functions": [ + [ + 0, + { + "NormalSym": "_ZN3std2rt19lang_start_internal17h035df9ff6960926aE" + } + ], + [ + 13, + { + "NormalSym": "_ZN3std3sys9backtrace28__rust_begin_short_backtrace17h9546aa68603b446bE" + } + ], + [ + 14, + { + "NormalSym": "_ZN54_$LT$$LP$$RP$$u20$as$u20$std..process..Termination$GT$6report17hfecd8929a76b2a1aE" + } + ], + [ + 19, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h418067ddc074e4f0E" + } + ], + [ + 20, + { + "IntrinsicSym": "black_box" + } + ], + [ + 21, + { + "NormalSym": "_ZN4core3ops8function6FnOnce9call_once17h6eae296bd34229cbE" + } + ], + [ + 23, + { + "NormalSym": "_ZN3std2rt10lang_start28_$u7b$$u7b$closure$u7d$$u7d$17hf1cf12d74b7cee38E" + } + ], + [ + 31, + { + "NoOpSym": "" + } + ] + ], + "uneval_consts": [], + "items": [ + { + "symbol_name": "_ZN24ptr_offset_negative_fail4main17h48f2426ab5b215b1E", + "mono_item_kind": { + "MonoItemFn": { + "name": "main", + "id": 6, + "body": { + "blocks": [ + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 1, + "projection": [] + }, + { + "Aggregate": [ + { + "Array": 16 + }, + [ + { + "Constant": { + "span": 51, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 9 + } + } + }, + { + "Constant": { + "span": 52, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 10 + } + } + }, + { + "Constant": { + "span": 53, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 3, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 11 + } + } + }, + { + "Constant": { + "span": 54, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 4, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 12 + } + } + }, + { + "Constant": { + "span": 55, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 4, + "mutability": "Mut" + } + }, + "ty": 16, + "id": 13 + } + } + } + ] + ] + } + ] + }, + "span": 56 + }, + { + "kind": { + "Assign": [ + { + "local": 4, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 57, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 14 + } + } + } + } + ] + }, + "span": 57 + }, + { + "kind": { + "Assign": [ + { + "local": 5, + "projection": [] + }, + { + "Use": { + "Constant": { + "span": 32, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 15 + } + } + } + } + ] + }, + "span": 50 + }, + { + "kind": { + "Assign": [ + { + "local": 6, + "projection": [] + }, + { + "BinaryOp": [ + "Lt", + { + "Copy": { + "local": 4, + "projection": [] + } + }, + { + "Copy": { + "local": 5, + "projection": [] + } + } + ] + } + ] + }, + "span": 50 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Move": { + "local": 6, + "projection": [] + } + }, + "expected": true, + "msg": { + "BoundsCheck": { + "len": { + "Move": { + "local": 5, + "projection": [] + } + }, + "index": { + "Copy": { + "local": 4, + "projection": [] + } + } + } + }, + "target": 1, + "unwind": "Continue" + } + }, + "span": 50 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 3, + "projection": [] + }, + { + "Ref": [ + { + "kind": "ReErased" + }, + "Shared", + { + "local": 1, + "projection": [ + { + "Index": 4 + } + ] + } + ] + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 2, + "projection": [] + }, + { + "AddressOf": [ + "Not", + { + "local": 3, + "projection": [ + "Deref" + ] + } + ] + } + ] + }, + "span": 59 + }, + { + "kind": { + "Assign": [ + { + "local": 7, + "projection": [] + }, + { + "BinaryOp": [ + "Offset", + { + "Copy": { + "local": 2, + "projection": [] + } + }, + { + "Constant": { + "span": 60, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 253, + 255, + 255, + 255, + 255, + 255, + 255, + 255 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 6, + "id": 16 + } + } + } + ] + } + ] + }, + "span": 61 + }, + { + "kind": { + "Assign": [ + { + "local": 9, + "projection": [] + }, + { + "Cast": [ + "PtrToPtr", + { + "Copy": { + "local": 7, + "projection": [] + } + }, + 26 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 10, + "projection": [] + }, + { + "Cast": [ + "Transmute", + { + "Copy": { + "local": 9, + "projection": [] + } + }, + 25 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 11, + "projection": [] + }, + { + "NullaryOp": [ + "AlignOf", + 16 + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 12, + "projection": [] + }, + { + "BinaryOp": [ + "Sub", + { + "Copy": { + "local": 11, + "projection": [] + } + }, + { + "Constant": { + "span": 58, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 17 + } + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 13, + "projection": [] + }, + { + "BinaryOp": [ + "BitAnd", + { + "Copy": { + "local": 10, + "projection": [] + } + }, + { + "Copy": { + "local": 12, + "projection": [] + } + } + ] + } + ] + }, + "span": 58 + }, + { + "kind": { + "Assign": [ + { + "local": 14, + "projection": [] + }, + { + "BinaryOp": [ + "Eq", + { + "Copy": { + "local": 13, + "projection": [] + } + }, + { + "Constant": { + "span": 58, + "user_ty": null, + "const_": { + "kind": { + "Allocated": { + "bytes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + }, + "ty": 25, + "id": 18 + } + } + } + ] + } + ] + }, + "span": 58 + } + ], + "terminator": { + "kind": { + "Assert": { + "cond": { + "Copy": { + "local": 14, + "projection": [] + } + }, + "expected": true, + "msg": { + "MisalignedPointerDereference": { + "required": { + "Copy": { + "local": 11, + "projection": [] + } + }, + "found": { + "Copy": { + "local": 10, + "projection": [] + } + } + } + }, + "target": 2, + "unwind": "Unreachable" + } + }, + "span": 58 + } + }, + { + "statements": [ + { + "kind": { + "Assign": [ + { + "local": 8, + "projection": [] + }, + { + "Use": { + "Copy": { + "local": 7, + "projection": [ + "Deref" + ] + } + } + } + ] + }, + "span": 58 + } + ], + "terminator": { + "kind": "Return", + "span": 62 + } + } + ], + "locals": [ + { + "ty": 1, + "span": 63, + "mutability": "Mut" + }, + { + "ty": 27, + "span": 64, + "mutability": "Not" + }, + { + "ty": 28, + "span": 65, + "mutability": "Not" + }, + { + "ty": 29, + "span": 59, + "mutability": "Not" + }, + { + "ty": 25, + "span": 57, + "mutability": "Not" + }, + { + "ty": 25, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 50, + "mutability": "Mut" + }, + { + "ty": 28, + "span": 66, + "mutability": "Not" + }, + { + "ty": 16, + "span": 67, + "mutability": "Not" + }, + { + "ty": 26, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 25, + "span": 58, + "mutability": "Mut" + }, + { + "ty": 30, + "span": 58, + "mutability": "Mut" + } + ], + "arg_count": 0, + "var_debug_info": [ + { + "name": "arr", + "source_info": { + "span": 64, + "scope": 1 + }, + "composite": null, + "value": { + "Place": { + "local": 1, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "ptr", + "source_info": { + "span": 65, + "scope": 2 + }, + "composite": null, + "value": { + "Place": { + "local": 2, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "p_oob", + "source_info": { + "span": 66, + "scope": 3 + }, + "composite": null, + "value": { + "Place": { + "local": 7, + "projection": [] + } + }, + "argument_index": null + }, + { + "name": "_x", + "source_info": { + "span": 67, + "scope": 4 + }, + "composite": null, + "value": { + "Place": { + "local": 8, + "projection": [] + } + }, + "argument_index": null + } + ], + "spread_arg": null, + "span": 68 + } + } + }, + "details": null + }, + { + "symbol_name": "_ZN3std2rt10lang_start17ha1fd183462332792E", + "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$17hf1cf12d74b7cee38E", + "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_backtrace17h9546aa68603b446bE", + "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$17h008625e426dac4beE", + "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_once17h418067ddc074e4f0E", + "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_once17h6eae296bd34229cbE", + "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$17h47eb61fbf7d4d979E", + "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$6report17hfecd8929a76b2a1aE", + "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 + } + } + } + } + ], + [ + 5, + { + "RefType": { + "pointee_type": 32, + "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": 33, + "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": 13, + "discriminants": [ + 0, + 1 + ], + "fields": [ + [ + 6 + ], + [ + 34 + ] + ], + "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": 18, + "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": 16, + "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": { + "Uint": "Usize" + } + } + ], + [ + 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, + { + "ArrayType": { + "elem_type": 16, + "size": { + "kind": { + "Value": [ + 25, + { + "bytes": [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "provenance": { + "ptrs": [] + }, + "align": 8, + "mutability": "Mut" + } + ] + }, + "id": 0 + }, + "layout": { + "fields": { + "Array": { + "stride": { + "num_bits": 32 + }, + "count": 5 + } + }, + "variants": { + "Single": { + "index": 0 + } + }, + "abi": { + "Aggregate": { + "sized": true + } + }, + "abi_align": 4, + "size": { + "num_bits": 160 + } + } + } + } + ], + [ + 28, + { + "PtrType": { + "pointee_type": 16, + "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, + { + "RefType": { + "pointee_type": 16, + "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, + { + "PrimitiveType": "Bool" + } + ], + [ + 33, + { + "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 + } + } + } + } + ], + [ + 34, + "VoidType" + ] + ], + "spans": [ + [ + 0, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 194, + 36 + ] + ], + [ + 1, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 17, + 199, + 6 + ] + ], + [ + 2, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 9, + 195, + 93 + ] + ], + [ + 3, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 10, + 195, + 93 + ] + ], + [ + 4, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 201, + 2, + 201, + 2 + ] + ], + [ + 5, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 5, + 199, + 6 + ] + ], + [ + 6, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 194, + 12, + 194, + 13 + ] + ], + [ + 7, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 199, + 6, + 199, + 7 + ] + ], + [ + 9, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 189, + 5, + 189, + 9 + ] + ], + [ + 10, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 190, + 5, + 190, + 9 + ] + ], + [ + 11, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 191, + 5, + 191, + 9 + ] + ], + [ + 12, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 192, + 5, + 192, + 12 + ] + ], + [ + 13, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 188, + 1, + 201, + 2 + ] + ], + [ + 14, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 69 + ] + ], + [ + 15, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 75 + ] + ], + [ + 16, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 18, + 195, + 84 + ] + ], + [ + 17, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 70, + 195, + 74 + ] + ], + [ + 18, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 76, + 195, + 82 + ] + ], + [ + 19, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 74, + 195, + 75 + ] + ], + [ + 20, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 93, + 195, + 93 + ] + ], + [ + 21, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 83, + 195, + 84 + ] + ], + [ + 22, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 9, + 2053, + 15 + ] + ], + [ + 23, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2053, + 23, + 2053, + 24 + ] + ], + [ + 27, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/rt.rs", + 195, + 92, + 195, + 93 + ] + ], + [ + 29, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2052, + 19, + 2052, + 23 + ] + ], + [ + 30, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 33 + ] + ], + [ + 35, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 389, + 5, + 389, + 40 + ] + ], + [ + 36, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/hint.rs", + 388, + 27, + 388, + 32 + ] + ], + [ + 42, + [ + "/Users/asli-ts/.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/asli-ts/.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/asli-ts/.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/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2424, + 6, + 2424, + 6 + ] + ], + [ + 46, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2423, + 9, + 2423, + 26 + ] + ], + [ + 48, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 15, + 2422, + 19 + ] + ], + [ + 49, + [ + "/Users/asli-ts/.rustup/toolchains/nightly-2024-11-29-aarch64-apple-darwin/lib/rustlib/src/rust/library/std/src/process.rs", + 2422, + 5, + 2424, + 6 + ] + ], + [ + 50, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 7, + 16, + 7, + 22 + ] + ], + [ + 51, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 16, + 6, + 20 + ] + ], + [ + 52, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 22, + 6, + 23 + ] + ], + [ + 53, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 25, + 6, + 26 + ] + ], + [ + 54, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 28, + 6, + 29 + ] + ], + [ + 55, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 31, + 6, + 32 + ] + ], + [ + 56, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 15, + 6, + 33 + ] + ], + [ + 57, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 7, + 20, + 7, + 21 + ] + ], + [ + 58, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 12, + 18, + 12, + 24 + ] + ], + [ + 59, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 7, + 15, + 7, + 22 + ] + ], + [ + 60, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 11, + 33, + 11, + 40 + ] + ], + [ + 61, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 11, + 21, + 11, + 41 + ] + ], + [ + 62, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 14, + 2, + 14, + 2 + ] + ], + [ + 64, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 6, + 9, + 6, + 12 + ] + ], + [ + 65, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 7, + 9, + 7, + 12 + ] + ], + [ + 66, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 11, + 13, + 11, + 18 + ] + ], + [ + 67, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 12, + 13, + 12, + 15 + ] + ], + [ + 68, + [ + "/Users/asli-ts/projects/mir-semantics/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs", + 5, + 1, + 14, + 2 + ] + ] + ], + "debug": null, + "machine": { + "endian": "Little", + "pointer_width": { + "num_bits": 64 + } + } +} diff --git a/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-negative-fail.state b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-negative-fail.state new file mode 100644 index 000000000..9e1cedaa1 --- /dev/null +++ b/kmir/src/tests/integration/data/exec-smir/pointers/ptr-offset-negative-fail.state @@ -0,0 +1,54 @@ + + + #execStmt ( statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpLt , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) ) ~> #execStmts ( .Statements ) ~> #execTerminator ( terminator (... kind: assert (... cond: operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageBoundsCheck (... len: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , index: operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionContinue ) , span: span ( 50 ) ) ) ~> .K + + + noReturn + + + ty ( -1 ) + + + + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 1 ) , projection: .ProjectionElems ) , rvalue: rvalueAggregate ( aggregateKindArray ( ty ( 16 ) ) , operandConstant ( constOperand (... span: span ( 51 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x01\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 9 ) ) ) ) operandConstant ( constOperand (... span: span ( 52 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x02\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 10 ) ) ) ) operandConstant ( constOperand (... span: span ( 53 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x03\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 11 ) ) ) ) operandConstant ( constOperand (... span: span ( 54 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x04\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 12 ) ) ) ) operandConstant ( constOperand (... span: span ( 55 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 4 ) , mutability: mutabilityMut ) ) , ty: ty ( 16 ) , id: mirConstId ( 13 ) ) ) ) .Operands ) ) , span: span ( 56 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 4 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 57 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x02\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 25 ) , id: mirConstId ( 14 ) ) ) ) ) ) , span: span ( 57 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 5 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandConstant ( constOperand (... span: span ( 32 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\x05\x00\x00\x00\x00\x00\x00\x00" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 25 ) , id: mirConstId ( 15 ) ) ) ) ) ) , span: span ( 50 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 6 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpLt , operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 50 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandMove ( place (... local: local ( 6 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageBoundsCheck (... len: operandMove ( place (... local: local ( 5 ) , projection: .ProjectionElems ) ) , index: operandCopy ( place (... local: local ( 4 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 1 ) , unwind: unwindActionContinue ) , span: span ( 50 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 3 ) , projection: .ProjectionElems ) , rvalue: rvalueRef ( region (... kind: regionKindReErased ) , borrowKindShared , place (... local: local ( 1 ) , projection: projectionElemIndex ( local ( 4 ) ) .ProjectionElems ) ) ) , span: span ( 59 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 2 ) , projection: .ProjectionElems ) , rvalue: rvalueAddressOf ( mutabilityNot , place (... local: local ( 3 ) , projection: projectionElemDeref .ProjectionElems ) ) ) , span: span ( 59 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 7 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpOffset , operandCopy ( place (... local: local ( 2 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 60 ) , userTy: noUserTypeAnnotationIndex , const: mirConst (... kind: constantKindAllocated ( allocation (... bytes: b"\xfd\xff\xff\xff\xff\xff\xff\xff" , provenance: provenanceMap (... ptrs: .ProvenanceMapEntries ) , align: align ( 8 ) , mutability: mutabilityMut ) ) , ty: ty ( 6 ) , id: mirConstId ( 16 ) ) ) ) ) ) , span: span ( 61 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 9 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindPtrToPtr , operandCopy ( place (... local: local ( 7 ) , projection: .ProjectionElems ) ) , ty ( 26 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 10 ) , projection: .ProjectionElems ) , rvalue: rvalueCast ( castKindTransmute , operandCopy ( place (... local: local ( 9 ) , projection: .ProjectionElems ) ) , ty ( 25 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 11 ) , projection: .ProjectionElems ) , rvalue: rvalueNullaryOp ( nullOpAlignOf , ty ( 16 ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 12 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpSub , operandCopy ( place (... local: local ( 11 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 58 ) , 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 ( 25 ) , id: mirConstId ( 17 ) ) ) ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 13 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpBitAnd , operandCopy ( place (... local: local ( 10 ) , projection: .ProjectionElems ) ) , operandCopy ( place (... local: local ( 12 ) , projection: .ProjectionElems ) ) ) ) , span: span ( 58 ) ) statement (... kind: statementKindAssign (... place: place (... local: local ( 14 ) , projection: .ProjectionElems ) , rvalue: rvalueBinaryOp ( binOpEq , operandCopy ( place (... local: local ( 13 ) , projection: .ProjectionElems ) ) , operandConstant ( constOperand (... span: span ( 58 ) , 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 ( 25 ) , id: mirConstId ( 18 ) ) ) ) ) ) , span: span ( 58 ) ) .Statements , terminator: terminator (... kind: assert (... cond: operandCopy ( place (... local: local ( 14 ) , projection: .ProjectionElems ) ) , expected: true , msg: assertMessageMisalignedPointerDereference (... required: operandCopy ( place (... local: local ( 11 ) , projection: .ProjectionElems ) ) , found: operandCopy ( place (... local: local ( 10 ) , projection: .ProjectionElems ) ) ) , target: basicBlockIdx ( 2 ) , unwind: unwindActionUnreachable ) , span: span ( 58 ) ) ) ) + ListItem ( basicBlock (... statements: statement (... kind: statementKindAssign (... place: place (... local: local ( 8 ) , projection: .ProjectionElems ) , rvalue: rvalueUse ( operandCopy ( place (... local: local ( 7 ) , projection: projectionElemDeref .ProjectionElems ) ) ) ) , span: span ( 58 ) ) .Statements , terminator: terminator (... kind: terminatorKindReturn , span: span ( 62 ) ) ) ) + + + ty ( -1 ) + + + place (... local: local ( 0 ) , projection: .ProjectionElems ) + + + noBasicBlockIdx + + + unwindActionContinue + + + ListItem ( newLocal ( ty ( 1 ) , mutabilityMut ) ) + ListItem ( typedValue ( Range ( ListItem ( Integer ( 1 , 32 , true ) ) + ListItem ( Integer ( 2 , 32 , true ) ) + ListItem ( Integer ( 3 , 32 , true ) ) + ListItem ( Integer ( 4 , 32 , true ) ) + ListItem ( Integer ( 5 , 32 , true ) ) ) , ty ( 27 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 29 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 2 , 64 , false ) , ty ( 25 ) , mutabilityNot ) ) + ListItem ( typedValue ( Integer ( 5 , 64 , false ) , ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 30 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 28 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 16 ) , mutabilityNot ) ) + ListItem ( newLocal ( ty ( 26 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 25 ) , mutabilityMut ) ) + ListItem ( newLocal ( ty ( 30 ) , 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/ptr-add.rs b/kmir/src/tests/integration/data/prove-rs/ptr-add.rs new file mode 100644 index 000000000..21f57f0f1 --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/ptr-add.rs @@ -0,0 +1,47 @@ +fn main() { + test_ptr_add_basic(); + test_ptr_add_multiple(); + test_ptr_add_to_end(); +} + +// Test basic ptr::add operation +fn test_ptr_add_basic() { + let arr = [10u8, 20, 30, 40]; + let ptr = &arr[0] as *const u8; + + unsafe { + let p1 = ptr.add(1); + assert_eq!(*p1, 20); + + let p3 = ptr.add(3); + assert_eq!(*p3, 40); + } +} + +// Test multiple add operations +fn test_ptr_add_multiple() { + let arr = [5i32, 10, 15, 20, 25, 30]; + let ptr = &arr[0] as *const i32; + + unsafe { + let p1 = ptr.add(1); + assert_eq!(*p1, 10); + + let p2 = p1.add(1); // Cumulative offset: 2 + assert_eq!(*p2, 15); + + let p3 = p2.add(1); // Cumulative offset: 3 + assert_eq!(*p3, 20); + } +} + +// Test adding to reach the end +fn test_ptr_add_to_end() { + let arr = [100u32, 200, 300]; + let ptr = &arr[0] as *const u32; + + unsafe { + let p_end = ptr.add(2); + assert_eq!(*p_end, 300); + } +} diff --git a/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs b/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs new file mode 100644 index 000000000..0acaab256 --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/ptr-offset-basic.rs @@ -0,0 +1,67 @@ +#![feature(core_intrinsics)] +use std::intrinsics::offset; + +fn main() { + test_offset_zero(); + test_offset_positive(); + test_offset_to_end(); + test_offset_negative(); +} + +// Test offset by 0 (trivial case) +fn test_offset_zero() { + let arr = [1i32, 2, 3, 4, 5]; + let ptr = &arr[0] as *const i32; + + unsafe { + let p0 = offset(ptr, 0isize); + assert_eq!(*p0, 1); + } +} + +// Test positive offset +fn test_offset_positive() { + let arr = [1i32, 2, 3, 4, 5]; + let ptr = &arr[0] as *const i32; + + unsafe { + // Offset by 2 + let p2 = offset(ptr, 2isize); + assert_eq!(*p2, 3); + + // Offset by 3 + let p3 = offset(ptr, 3isize); + assert_eq!(*p3, 4); + } +} + +// Test offset to last element +fn test_offset_to_end() { + let arr = [1i32, 2, 3, 4, 5]; + let ptr = &arr[0] as *const i32; + + unsafe { + let p4 = offset(ptr, 4isize); + assert_eq!(*p4, 5); + } +} + +// Test negative offset (moving backwards) +fn test_offset_negative() { + let arr = [10i32, 20, 30, 40, 50]; + let ptr = &arr[3] as *const i32; // Start at element 3 (value 40) + + unsafe { + // Move back 2 positions + let p_back = offset(ptr, -2isize); + assert_eq!(*p_back, 20); + + // Move back 1 position + let p_back1 = offset(ptr, -1isize); + assert_eq!(*p_back1, 30); + + // Stay at current position + let p_same = offset(ptr, 0isize); + assert_eq!(*p_same, 40); + } +} diff --git a/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs b/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs new file mode 100644 index 000000000..adc3f6cee --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/ptr-offset-bounds-fail.rs @@ -0,0 +1,14 @@ +#![feature(core_intrinsics)] +use std::intrinsics::offset; + +// This test should fail - offset beyond array bounds +fn main() { + let arr = [1i32, 2, 3, 4, 5]; + let ptr = &arr[0] as *const i32; + + unsafe { + // This should trigger UB - offsetting beyond the end + let p_oob = offset(ptr, 6isize); + let _x = *p_oob; // Accessing out of bounds + } +} diff --git a/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs b/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs new file mode 100644 index 000000000..d3ad3e594 --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/ptr-offset-negative-fail.rs @@ -0,0 +1,14 @@ +#![feature(core_intrinsics)] +use std::intrinsics::offset; + +// This test should fail - negative offset before array start +fn main() { + let arr = [1i32, 2, 3, 4, 5]; + let ptr = &arr[2] as *const i32; // Start at element 2 (value 3) + + unsafe { + // This should trigger UB - offsetting before the start + let p_oob = offset(ptr, -3isize); // Would go to index -1 + let _x = *p_oob; // Accessing before array start + } +} diff --git a/kmir/src/tests/integration/data/prove-rs/ptr-sub.rs b/kmir/src/tests/integration/data/prove-rs/ptr-sub.rs new file mode 100644 index 000000000..db6926d75 --- /dev/null +++ b/kmir/src/tests/integration/data/prove-rs/ptr-sub.rs @@ -0,0 +1,47 @@ +fn main() { + test_ptr_sub_basic(); + test_ptr_sub_to_start(); + test_ptr_add_then_sub(); +} + +// Test basic ptr::sub operation +fn test_ptr_sub_basic() { + let arr = [1u8, 2, 3, 4, 5]; + let ptr = &arr[3] as *const u8; // Start at element 3 (value 4) + + unsafe { + let p_back = ptr.sub(1); + assert_eq!(*p_back, 3); + + let p_back2 = ptr.sub(2); + assert_eq!(*p_back2, 2); + } +} + +// Test subtracting to reach the start +fn test_ptr_sub_to_start() { + let arr = [10i32, 20, 30, 40, 50]; + let ptr = &arr[4] as *const i32; // Start at last element (value 50) + + unsafe { + let p_start = ptr.sub(4); + assert_eq!(*p_start, 10); + } +} + +// Test combination of add and sub +fn test_ptr_add_then_sub() { + let arr = [100u32, 200, 300, 400, 500]; + let ptr = &arr[0] as *const u32; + + unsafe { + let p_forward = ptr.add(3); // Move to element 3 (value 400) + assert_eq!(*p_forward, 400); + + let p_back = p_forward.sub(1); // Move back to element 2 (value 300) + assert_eq!(*p_back, 300); + + let p_back2 = p_back.sub(2); // Move back to element 0 (value 100) + assert_eq!(*p_back2, 100); + } +} diff --git a/kmir/src/tests/integration/data/run-smir-random/complex-types/final-0.expected b/kmir/src/tests/integration/data/run-smir-random/complex-types/final-0.expected index 0c9a838cd..d5164caa7 100644 --- a/kmir/src/tests/integration/data/run-smir-random/complex-types/final-0.expected +++ b/kmir/src/tests/integration/data/run-smir-random/complex-types/final-0.expected @@ -50,12 +50,12 @@ ListItem ( typedValue ( Integer ( 0 , 64 , false ) , ty ( 3 ) , mutabilityNot ) ) ListItem ( newLocal ( ty ( 23 ) , mutabilityMut ) ) ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , metadata ( dynamicSize ( 8 ) , 0 , noMetadataSize ) ) , ty ( 50 ) , mutabilityMut ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , dynamicSize ( 8 ) ) ) , ty ( 53 ) , mutabilityNot ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , metadata ( dynamicSize ( 8 ) , 0 , noMetadataSize ) ) , ty ( 15 ) , mutabilityMut ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , dynamicSize ( 8 ) ) ) ) , ty ( 53 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( dynamicSize ( 8 ) , 0 , noMetadataSize ) ) ) , ty ( 15 ) , mutabilityMut ) ) ListItem ( typedValue ( Moved , ty ( 4 ) , mutabilityMut ) ) ListItem ( newLocal ( ty ( 2 ) , mutabilityNot ) ) ListItem ( typedValue ( Moved , ty ( 4 ) , mutabilityMut ) ) - ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , metadata ( noMetadataSize , 0 , dynamicSize ( 8 ) ) ) , ty ( 53 ) , mutabilityNot ) ) + ListItem ( typedValue ( PtrLocal ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , ptrEmulation ( metadata ( noMetadataSize , 0 , dynamicSize ( 8 ) ) ) ) , ty ( 53 ) , mutabilityNot ) ) ListItem ( newLocal ( ty ( 2 ) , mutabilityNot ) ) ListItem ( newLocal ( ty ( 54 ) , mutabilityMut ) ) ListItem ( typedValue ( Reference ( 1 , place (... local: local ( 30 ) , projection: projectionElemField ( fieldIdx ( 0 ) , ty ( 11 ) ) .ProjectionElems ) , mutabilityNot , metadata ( staticSize ( 8 ) , 0 , noMetadataSize ) ) , ty ( 57 ) , mutabilityMut ) ) diff --git a/kmir/src/tests/integration/test_integration.py b/kmir/src/tests/integration/test_integration.py index 345143b26..4e3a715af 100644 --- a/kmir/src/tests/integration/test_integration.py +++ b/kmir/src/tests/integration/test_integration.py @@ -256,6 +256,36 @@ def test_crate_examples(main_crate: Path, kmir: KMIR, update_expected_output: bo EXEC_DATA_DIR / 'pointers' / 'pointer-cast-length-test-fail.state', 1000, ), + ( + 'ptr_add', + EXEC_DATA_DIR / 'pointers' / 'ptr-add.smir.json', + EXEC_DATA_DIR / 'pointers' / 'ptr-add.state', + 100, + ), + ( + 'ptr_offset_basic', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-basic.smir.json', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-basic.state', + 150, + ), + ( + 'ptr_offset_bounds_fail', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-bounds-fail.smir.json', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-bounds-fail.state', + 50, + ), + ( + 'ptr_offset_negative_fail', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-negative-fail.smir.json', + EXEC_DATA_DIR / 'pointers' / 'ptr-offset-negative-fail.state', + 50, + ), + ( + 'pointer_offset', + EXEC_DATA_DIR / 'pointer_offset_test.smir.json', + EXEC_DATA_DIR / 'pointer_offset_test.state', + 100, + ), ( 'ref-ptr-cases', EXEC_DATA_DIR / 'pointers' / 'ref_ptr_cases.smir.json',