temp

Author: nia-e

compiler/rustc_const_eval/src/const_eval/dummy_machine.rs

@@ -197,4 +197,9 @@ impl<'tcx> interpret::Machine<'tcx> for DummyMachine {
     ) -> &'a mut Vec<interpret::Frame<'tcx, Self::Provenance, Self::FrameExtra>> {
         unimplemented!()
     }
+
+    fn get_default_byte_mdata(
+        &self,
+    ) -> <Self::Bytes as rustc_middle::mir::interpret::AllocBytes>::ByteMetadata {
+    }
 }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -735,6 +735,8 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
             Cow::Owned(compute_range())
         }
     }
+
+    fn get_default_byte_mdata(&self) -> <Self::Bytes as mir::interpret::AllocBytes>::ByteMetadata {}
 }
 
 // Please do not add any code below the above `Machine` trait impl. I (oli-obk) plan more cleanups

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -26,7 +26,7 @@ use crate::fluent_generated as fluent;
 /// Directly returns an `Allocation` containing an absolute path representation of the given type.
 pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAllocation<'tcx> {
     let path = crate::util::type_name(tcx, ty);
-    let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());
+    let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes(), ());
     tcx.mk_const_alloc(alloc)
 }
 

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -628,6 +628,8 @@ pub trait Machine<'tcx>: Sized {
         // Default to no caching.
         Cow::Owned(compute_range())
     }
+
+    fn get_default_byte_mdata(&self) -> <Self::Bytes as AllocBytes>::ByteMetadata;
 }
 
 /// A lot of the flexibility above is just needed for `Miri`, but all "compile-time" machines

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -233,10 +233,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         kind: MemoryKind<M::MemoryKind>,
         init: AllocInit,
     ) -> InterpResult<'tcx, Pointer<M::Provenance>> {
+        let dsc = self.machine.get_default_byte_mdata();
         let alloc = if M::PANIC_ON_ALLOC_FAIL {
-            Allocation::new(size, align, init)
+            Allocation::new(size, align, init, dsc)
         } else {
-            Allocation::try_new(size, align, init)?
+            Allocation::try_new(size, align, init, dsc)?
         };
         self.insert_allocation(alloc, kind)
     }
@@ -248,7 +249,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         kind: MemoryKind<M::MemoryKind>,
         mutability: Mutability,
     ) -> InterpResult<'tcx, Pointer<M::Provenance>> {
-        let alloc = Allocation::from_bytes(bytes, align, mutability);
+        let dsc = self.machine.get_default_byte_mdata();
+        let alloc = Allocation::from_bytes(bytes, align, mutability, dsc);
         self.insert_allocation(alloc, kind)
     }
 

compiler/rustc_const_eval/src/interpret/util.rs

@@ -38,7 +38,7 @@ pub(crate) fn create_static_alloc<'tcx>(
     static_def_id: LocalDefId,
     layout: TyAndLayout<'tcx>,
 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
-    let alloc = Allocation::try_new(layout.size, layout.align.abi, AllocInit::Uninit)?;
+    let alloc = Allocation::try_new(layout.size, layout.align.abi, AllocInit::Uninit, ())?;
     let alloc_id = ecx.tcx.reserve_and_set_static_alloc(static_def_id.into());
     assert_eq!(ecx.machine.static_root_ids, None);
     ecx.machine.static_root_ids = Some((alloc_id, static_def_id));

compiler/rustc_middle/src/mir/interpret/allocation.rs

@@ -29,7 +29,7 @@ use crate::ty;
 pub trait AllocBytes: Clone + fmt::Debug + Deref<Target = [u8]> + DerefMut<Target = [u8]> {
     /// Used for giving extra metadata on creation. Miri uses this to allow
     /// machine memory to be allocated separately from other allocations.
-    type ByteMetadata: Default + Clone + fmt::Debug;
+    type ByteMetadata: Clone + fmt::Debug;
 
     /// Create an `AllocBytes` from a slice of `u8`.
     fn from_bytes<'a>(
@@ -55,6 +55,9 @@ pub trait AllocBytes: Clone + fmt::Debug + Deref<Target = [u8]> + DerefMut<Targe
     /// - other pointers returned by this method, and
     /// - references returned from `deref()`, as long as there was no write.
     fn as_ptr(&self) -> *const u8;
+
+    /// Gets the allocation metadata.
+    fn get_mdata(&self) -> Self::ByteMetadata;
 }
 
 /// Default `bytes` for `Allocation` is a `Box<u8>`.
@@ -79,6 +82,8 @@ impl AllocBytes for Box<[u8]> {
     fn as_ptr(&self) -> *const u8 {
         Box::as_ptr(self).cast()
     }
+
+    fn get_mdata(&self) -> () {}
 }
 
 /// This type represents an Allocation in the Miri/CTFE core engine.
@@ -185,6 +190,7 @@ fn all_zero(buf: &[u8]) -> bool {
 impl<Prov: Provenance, Extra, Bytes, E: Encoder> Encodable<E> for Allocation<Prov, Extra, Bytes>
 where
     Bytes: AllocBytes,
+    Bytes::ByteMetadata: Encodable<E>,
     ProvenanceMap<Prov>: Encodable<E>,
     Extra: Encodable<E>,
 {
@@ -196,6 +202,7 @@ where
         if !all_zero {
             encoder.emit_raw_bytes(&self.bytes);
         }
+        self.bytes.get_mdata().encode(encoder);
         self.provenance.encode(encoder);
         self.init_mask.encode(encoder);
         self.extra.encode(encoder);
@@ -205,6 +212,7 @@ where
 impl<Prov: Provenance, Extra, Bytes, D: Decoder> Decodable<D> for Allocation<Prov, Extra, Bytes>
 where
     Bytes: AllocBytes,
+    Bytes::ByteMetadata: Decodable<D>,
     ProvenanceMap<Prov>: Decodable<D>,
     Extra: Decodable<D>,
 {
@@ -213,7 +221,9 @@ where
 
         let len = decoder.read_usize();
         let bytes = if all_zero { vec![0u8; len] } else { decoder.read_raw_bytes(len).to_vec() };
-        let bytes = Bytes::from_bytes(bytes, align, Bytes::ByteMetadata::default());
+
+        let mdata = Decodable::decode(decoder);
+        let bytes = Bytes::from_bytes(bytes, align, mdata);
 
         let provenance = Decodable::decode(decoder);
         let init_mask = Decodable::decode(decoder);
@@ -405,8 +415,9 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
         slice: impl Into<Cow<'a, [u8]>>,
         align: Align,
         mutability: Mutability,
+        dsc: <Bytes as AllocBytes>::ByteMetadata,
     ) -> Self {
-        let bytes = Bytes::from_bytes(slice, align, Bytes::ByteMetadata::default());
+        let bytes = Bytes::from_bytes(slice, align, dsc);
         let size = Size::from_bytes(bytes.len());
         Self {
             bytes,
@@ -418,14 +429,18 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
         }
     }
 
-    pub fn from_bytes_byte_aligned_immutable<'a>(slice: impl Into<Cow<'a, [u8]>>) -> Self {
-        Allocation::from_bytes(slice, Align::ONE, Mutability::Not)
+    pub fn from_bytes_byte_aligned_immutable<'a>(
+        slice: impl Into<Cow<'a, [u8]>>,
+        dsc: <Bytes as AllocBytes>::ByteMetadata,
+    ) -> Self {
+        Allocation::from_bytes(slice, Align::ONE, Mutability::Not, dsc)
     }
 
     fn new_inner<R>(
         size: Size,
         align: Align,
         init: AllocInit,
+        dsc: <Bytes as AllocBytes>::ByteMetadata,
         fail: impl FnOnce() -> R,
     ) -> Result<Self, R> {
         // We raise an error if we cannot create the allocation on the host.
@@ -434,7 +449,7 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
         // deterministic. However, we can be non-deterministic here because all uses of const
         // evaluation (including ConstProp!) will make compilation fail (via hard error
         // or ICE) upon encountering a `MemoryExhausted` error.
-        let bytes = Bytes::zeroed(size, align, Bytes::ByteMetadata::default()).ok_or_else(fail)?;
+        let bytes = Bytes::zeroed(size, align, dsc).ok_or_else(fail)?;
 
         Ok(Allocation {
             bytes,
@@ -454,8 +469,13 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
 
     /// Try to create an Allocation of `size` bytes, failing if there is not enough memory
     /// available to the compiler to do so.
-    pub fn try_new<'tcx>(size: Size, align: Align, init: AllocInit) -> InterpResult<'tcx, Self> {
-        Self::new_inner(size, align, init, || {
+    pub fn try_new<'tcx>(
+        size: Size,
+        align: Align,
+        init: AllocInit,
+        dsc: <Bytes as AllocBytes>::ByteMetadata,
+    ) -> InterpResult<'tcx, Self> {
+        Self::new_inner(size, align, init, dsc, || {
             ty::tls::with(|tcx| tcx.dcx().delayed_bug("exhausted memory during interpretation"));
             InterpErrorKind::ResourceExhaustion(ResourceExhaustionInfo::MemoryExhausted)
         })
@@ -467,8 +487,13 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
     ///
     /// Example use case: To obtain an Allocation filled with specific data,
     /// first call this function and then call write_scalar to fill in the right data.
-    pub fn new(size: Size, align: Align, init: AllocInit) -> Self {
-        match Self::new_inner(size, align, init, || {
+    pub fn new(
+        size: Size,
+        align: Align,
+        init: AllocInit,
+        dsc: <Bytes as AllocBytes>::ByteMetadata,
+    ) -> Self {
+        match Self::new_inner(size, align, init, dsc, || {
             panic!(
                 "interpreter ran out of memory: cannot create allocation of {} bytes",
                 size.bytes()

compiler/rustc_middle/src/ty/context.rs

@@ -1579,7 +1579,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Returns the same `AllocId` if called again with the same bytes.
     pub fn allocate_bytes_dedup(self, bytes: &[u8], salt: usize) -> interpret::AllocId {
         // Create an allocation that just contains these bytes.
-        let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes);
+        let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes, ());
         let alloc = self.mk_const_alloc(alloc);
         self.reserve_and_set_memory_dedup(alloc, salt)
     }

compiler/rustc_middle/src/ty/vtable.rs

@@ -110,7 +110,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
     let ptr_align = tcx.data_layout.pointer_align.abi;
 
     let vtable_size = ptr_size * u64::try_from(vtable_entries.len()).unwrap();
-    let mut vtable = Allocation::new(vtable_size, ptr_align, AllocInit::Uninit);
+    let mut vtable = Allocation::new(vtable_size, ptr_align, AllocInit::Uninit, ());
 
     // No need to do any alignment checks on the memory accesses below, because we know the
     // allocation is correctly aligned as we created it above. Also we're only offsetting by

compiler/rustc_mir_build/src/builder/expr/as_constant.rs

@@ -121,14 +121,14 @@ fn lit_to_mir_constant<'tcx>(tcx: TyCtxt<'tcx>, lit_input: LitToConstInput<'tcx>
     let value = match (lit, lit_ty.kind()) {
         (ast::LitKind::Str(s, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_str() => {
             let s = s.as_str();
-            let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());
+            let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes(), ());
             let allocation = tcx.mk_const_alloc(allocation);
             ConstValue::Slice { data: allocation, meta: allocation.inner().size().bytes() }
         }
         (ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _))
             if matches!(inner_ty.kind(), ty::Slice(_)) =>
         {
-            let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8]);
+            let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8], ());
             let allocation = tcx.mk_const_alloc(allocation);
             ConstValue::Slice { data: allocation, meta: allocation.inner().size().bytes() }
         }
@@ -138,7 +138,7 @@ fn lit_to_mir_constant<'tcx>(tcx: TyCtxt<'tcx>, lit_input: LitToConstInput<'tcx>
         }
         (ast::LitKind::CStr(data, _), ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::CStr)) =>
         {
-            let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8]);
+            let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8], ());
             let allocation = tcx.mk_const_alloc(allocation);
             ConstValue::Slice { data: allocation, meta: allocation.inner().size().bytes() }
         }

compiler/rustc_mir_transform/src/large_enums.rs

@@ -241,6 +241,7 @@ impl EnumSizeOpt {
             data,
             tcx.data_layout.ptr_sized_integer().align(&tcx.data_layout).abi,
             Mutability::Not,
+            (),
         );
         let alloc = tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(alloc));
         Some((*adt_def, num_discrs, *alloc_cache.entry(ty).or_insert(alloc)))

compiler/rustc_smir/src/rustc_smir/alloc.rs

@@ -48,6 +48,7 @@ pub(crate) fn try_new_allocation<'tcx>(
                 size,
                 layout.align.abi,
                 AllocInit::Uninit,
+                (),
             );
             allocation
                 .write_scalar(&tables.tcx, alloc_range(Size::ZERO, size), scalar)
@@ -65,6 +66,7 @@ pub(crate) fn try_new_allocation<'tcx>(
                 layout.size,
                 layout.align.abi,
                 AllocInit::Uninit,
+                (),
             );
             allocation
                 .write_scalar(

src/tools/miri/src/alloc/alloc_bytes.rs

@@ -9,9 +9,8 @@ use rustc_middle::mir::interpret::AllocBytes;
 use crate::alloc::discrete_alloc::MachineAlloc;
 use crate::helpers::ToU64 as _;
 
-#[derive(Clone, Copy, Debug, Default)]
+#[derive(Clone, Copy, Debug)]
 pub enum MiriByteMdata {
-    #[default]
     Global,
     Isolated,
 }
@@ -163,4 +162,8 @@ impl AllocBytes for MiriAllocBytes {
     fn as_ptr(&self) -> *const u8 {
         self.ptr
     }
+
+    fn get_mdata(&self) -> MiriByteMdata {
+        self.dsc
+    }
 }

src/tools/miri/src/alloc/discrete_alloc.rs

@@ -25,38 +25,21 @@ pub struct MachineAlloc {
     allocated: Vec<Box<[u8]>>,
     /// The host (not emulated) page size.
     page_size: usize,
-    /// If false, calls to `alloc()` and `alloc_zeroed()` just wrap the corresponding
-    /// function in the global allocator. Otherwise, uses the pages tracked
-    /// internally.
-    enabled: bool,
 }
 
 // SAFETY: We only point to heap-allocated data
 unsafe impl Send for MachineAlloc {}
 
 impl MachineAlloc {
-    /// Initializes the allocator. `page_size` is set to 4k as a placeholder to
-    /// allow this function to be `const`; it is updated to its real value when
-    /// `enable()` is called.
+    /// Initializes the allocator. `page_size` is set to 0 as a placeholder to
+    /// allow this function to be `const`; it is updated to its real value on
+    /// the first call to `alloc()` or `alloc_zeroed()`.
     const fn empty() -> Self {
         Self {
             pages: Vec::new(),
             huge_allocs: Vec::new(),
             allocated: Vec::new(),
-            page_size: 4096,
-            enabled: true,
-        }
-    }
-
-    /// Enables the allocator. From this point onwards, calls to `alloc()` and
-    /// `alloc_zeroed()` will return `(ptr, false)`.
-    pub fn enable() {
-        let mut alloc = ALLOCATOR.lock().unwrap();
-        alloc.enabled = true;
-        // This needs to specifically be the system pagesize!
-        alloc.page_size = unsafe {
-            // If sysconf errors, better to just panic
-            libc::sysconf(libc::_SC_PAGE_SIZE).try_into().unwrap()
+            page_size: 0,
         }
     }
 
@@ -79,13 +62,9 @@ impl MachineAlloc {
         (size, align)
     }
 
-    /// Allocates memory as described in `Layout`. If `MachineAlloc::enable()`
-    /// has *not* been called yet, this is just a wrapper for `(alloc::alloc(),
-    /// true)`. Otherwise, it will allocate from its own memory pool and
-    /// return `(ptr, false)`. The latter field is meant to correspond with the
-    /// field `alloc_is_global` for `MiriAllocBytes`.
+    /// Allocates memory as described in `Layout`.
     ///
-    /// SAFETY: See alloc::alloc()
+    /// SAFETY: `See alloc::alloc()`
     #[inline]
     pub unsafe fn alloc(layout: Layout) -> *mut u8 {
         let mut alloc = ALLOCATOR.lock().unwrap();
@@ -94,21 +73,24 @@ impl MachineAlloc {
         }
     }
 
-    /// Same as `alloc()`, but zeroes out data before allocating. Instead
-    /// wraps `alloc::alloc_zeroed()` if `MachineAlloc::enable()` has not been
-    /// called yet.
+    /// Same as `alloc()`, but zeroes out data before allocating.
     ///
-    /// SAFETY: See alloc::alloc_zeroed()
+    /// SAFETY: See `alloc::alloc_zeroed()`
     pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
         let mut alloc = ALLOCATOR.lock().unwrap();
         unsafe { alloc.alloc_inner(layout, true) }
     }
 
-    /// SAFETY: The allocator must have been `enable()`d already and
-    /// the `layout` must be valid.
+    /// SAFETY: See `alloc::alloc()`
     unsafe fn alloc_inner(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
         let (size, align) = MachineAlloc::normalized_layout(layout);
 
+        if self.page_size == 0 {
+            unsafe {
+                self.page_size = libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap();
+            }
+        }
+
         if align > self.page_size || size > self.page_size {
             unsafe { self.alloc_multi_page(layout, zeroed) }
         } else {
@@ -151,13 +133,10 @@ impl MachineAlloc {
         ret
     }
 
-    /// Deallocates a pointer from the machine allocator. While not unsound,
-    /// attempting to deallocate a pointer if `MachineAlloc` has not been enabled
-    /// will likely result in a panic.
+    /// Deallocates a pointer from the isolated allocator.
     ///
     /// SAFETY: This pointer must have been allocated with `MachineAlloc::alloc()`
-    /// (or `alloc_zeroed()`) which must have returned `(ptr, false)` specifically!
-    /// If it returned `(ptr, true)`, then deallocate it with `alloc::dealloc()` instead.
+    /// (or `alloc_zeroed()`) with the same layout as the one passed.
     pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
         let mut alloc_guard = ALLOCATOR.lock().unwrap();
         // Doing it this way lets us grab 2 mutable references to different fields at once