fix init_allocation_extra

Author: RalfJung

src/eval.rs

@@ -87,7 +87,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
             arg.push(0);
             argvs.push(
                 ecx.memory
-                    .allocate_static_bytes(arg.as_slice(), MiriMemoryKind::Static.into()),
+                    .allocate_static_bytes(arg.as_slice(), MiriMemoryKind::Env.into()),
             );
         }
         // Make an array with all these pointers, in the Miri memory.
@@ -138,7 +138,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     // Return place (in static memory so that it does not count as leak).
     let ret_place = ecx.allocate(
         ecx.layout_of(tcx.types.isize)?,
-        MiriMemoryKind::Static.into(),
+        MiriMemoryKind::Env.into(),
     );
     // Call start function.
     ecx.call_function(
@@ -150,7 +150,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
 
     // Set the last_error to 0
     let errno_layout = ecx.layout_of(tcx.types.u32)?;
-    let errno_place = ecx.allocate(errno_layout, MiriMemoryKind::Static.into());
+    let errno_place = ecx.allocate(errno_layout, MiriMemoryKind::Env.into());
     ecx.write_scalar(Scalar::from_u32(0), errno_place.into())?;
     ecx.machine.last_error = Some(errno_place);
 

src/machine.rs

@@ -43,9 +43,9 @@ pub enum MiriMemoryKind {
     C,
     /// Windows `HeapAlloc` memory.
     WinHeap,
-    /// Part of env var emulation.
+    /// Memory for env vars and args, errno and other parts of the machine-managed environment.
     Env,
-    /// Statics.
+    /// Rust statics.
     Static,
 }
 
@@ -296,19 +296,20 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         id: AllocId,
         alloc: Cow<'b, Allocation>,
         kind: Option<MemoryKind<Self::MemoryKinds>>,
-    ) -> Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>> {
+    ) -> (Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>>, Self::PointerTag) {
         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
         let alloc = alloc.into_owned();
-        let stacks = if memory_extra.validate {
-            Some(Stacks::new_allocation(
+        let (stacks, base_tag) = if memory_extra.validate {
+            let (stacks, base_tag) = Stacks::new_allocation(
                 id,
                 alloc.size,
                 Rc::clone(&memory_extra.stacked_borrows),
                 kind,
-            ))
+            );
+            (Some(stacks), base_tag)
         } else {
-            // No stacks.
-            None
+            // No stacks, no tag.
+            (None, Tag::Untagged)
         };
         let mut stacked_borrows = memory_extra.stacked_borrows.borrow_mut();
         let alloc: Allocation<Tag, Self::AllocExtra> = alloc.with_tags_and_extra(
@@ -325,7 +326,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
                 stacked_borrows: stacks,
             },
         );
-        Cow::Owned(alloc)
+        (Cow::Owned(alloc), base_tag)
     }
 
     #[inline(always)]

src/shims/panic.rs

@@ -187,7 +187,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
                 // First arg: Message.
                 let msg = msg.description();
-                let msg = this.allocate_str(msg, MiriMemoryKind::Static.into());
+                let msg = this.allocate_str(msg, MiriMemoryKind::Env.into());
 
                 // Second arg: Caller location.
                 let location = this.alloc_caller_location_for_span(span);

src/stacked_borrows.rs

@@ -462,7 +462,7 @@ impl Stacks {
         size: Size,
         extra: MemoryExtra,
         kind: MemoryKind<MiriMemoryKind>,
-    ) -> Self {
+    ) -> (Self, Tag) {
         let (tag, perm) = match kind {
             MemoryKind::Stack =>
                 // New unique borrow. This tag is not accessible by the program,
@@ -472,15 +472,17 @@ impl Stacks {
                 // and in particular, *all* raw pointers.
                 (Tag::Tagged(extra.borrow_mut().new_ptr()), Permission::Unique),
             MemoryKind::Machine(MiriMemoryKind::Static) =>
-                // Statics are inherently shared, so we do not derive any uniqueness assumptions
-                // from direct accesses to a static. Thus, the base permission is `SharedReadWrite`.
+                // Static memory can be referenced by "global" pointers from `tcx`.
+                // Thus we call `static_base_ptr` such that the global pointers get the same tag
+                // as what we use here.
+                // The base pointer is not unique, so the base permission is `SharedReadWrite`.
                 (extra.borrow_mut().static_base_ptr(id), Permission::SharedReadWrite),
             _ =>
                 // Everything else we handle entirely untagged for now.
                 // FIXME: experiment with more precise tracking.
                 (Tag::Untagged, Permission::SharedReadWrite),
         };
-        Stacks::new(size, perm, tag, extra)
+        (Stacks::new(size, perm, tag, extra), tag)
     }
 
     #[inline(always)]