Alignment of the bytes of Allocation to match align parameter

Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "abort_on_panic"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955f37ac58af2416bac687c8ab66a4ccba282229bd7422a28d2281a5e66a6116"
+
 [[package]]
 name = "addr2line"
 version = "0.16.0"
@@ -2151,6 +2157,26 @@ dependencies = [
  "rustc-std-workspace-core",
 ]
 
+[[package]]
+name = "libffi"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e08093a2ddeee94bd0c830a53d895ff91f1f3bb0f9b3c8c6b00739cdf76bc1d"
+dependencies = [
+ "abort_on_panic",
+ "libc",
+ "libffi-sys",
+]
+
+[[package]]
+name = "libffi-sys"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab4106b7f09d7b87d021334d5618fac1dfcfb824d4c5fe111ff0074dfd242e15"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "libgit2-sys"
 version = "0.13.2+1.4.2"
@@ -2482,6 +2508,8 @@ dependencies = [
  "getrandom 0.2.0",
  "lazy_static",
  "libc",
+ "libffi",
+ "libloading",
  "log",
  "measureme",
  "rand 0.8.5",

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -518,6 +518,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         )
     }
 
+    /// Get the base address for the bytes in an `Allocation` specified by the 
+    /// `AllocID` passed in; error if no such allocation exists.
+    pub fn get_alloc_base_addr(&self, id: AllocId) -> InterpResult<'tcx, Size> {
+        let alloc = self.get_alloc_raw(id)?;
+        Ok(alloc.get_bytes_addr())
+    }
+
     /// Gives raw access to the `Allocation`, without bounds or alignment checks.
     /// The caller is responsible for calling the access hooks!
     fn get_alloc_raw(

compiler/rustc_middle/src/lib.rs

@@ -23,6 +23,7 @@
 //! This API is completely unstable and subject to change.
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
+#![feature(maybe_uninit_write_slice)]
 #![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(assert_matches)]
@@ -60,6 +61,7 @@
 #![feature(intra_doc_pointers)]
 #![feature(yeet_expr)]
 #![feature(const_option)]
+#![feature(vec_into_raw_parts)]
 #![recursion_limit = "512"]
 #![allow(rustc::potential_query_instability)]
 

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

@@ -7,6 +7,7 @@ use std::hash;
 use std::iter;
 use std::ops::{Deref, Range};
 use std::ptr;
+use std::mem::MaybeUninit;
 
 use rustc_ast::Mutability;
 use rustc_data_structures::intern::Interned;
@@ -207,8 +208,19 @@ impl<Prov> Allocation<Prov> {
         align: Align,
         mutability: Mutability,
     ) -> Self {
-        let bytes = Box::<[u8]>::from(slice.into());
-        let size = Size::from_bytes(bytes.len());
+        let slice: Cow<'a, [u8]> = slice.into();
+        let size = Size::from_bytes(slice.len());
+        let align_usize: usize = align.bytes().try_into().unwrap();
+        let layout = std::alloc::Layout::from_size_align(slice.len(), align_usize).unwrap();
+        let bytes = unsafe {
+            let buf = std::alloc::alloc(layout);
+            let mut boxed = Box::<[MaybeUninit<u8>]>::from_raw(std::slice::from_raw_parts_mut(buf as *mut MaybeUninit<u8>, slice.len()));
+            MaybeUninit::write_slice(&mut boxed, &slice);
+            boxed.assume_init()
+        };
+
+        assert!(bytes.as_ptr() as u64 % align.bytes() == 0);
+
         Self {
             bytes,
             relocations: Relocations::new(),
@@ -228,22 +240,29 @@ impl<Prov> Allocation<Prov> {
     ///
     /// If `panic_on_fail` is true, this will never return `Err`.
     pub fn uninit<'tcx>(size: Size, align: Align, panic_on_fail: bool) -> InterpResult<'tcx, Self> {
-        let bytes = Box::<[u8]>::try_new_zeroed_slice(size.bytes_usize()).map_err(|_| {
-            // This results in an error that can happen non-deterministically, since the memory
-            // available to the compiler can change between runs. Normally queries are always
-            // 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.
-            if panic_on_fail {
-                panic!("Allocation::uninit called with panic_on_fail had allocation failure")
-            }
-            ty::tls::with(|tcx| {
-                tcx.sess.delay_span_bug(DUMMY_SP, "exhausted memory during interpretation")
-            });
-            InterpError::ResourceExhaustion(ResourceExhaustionInfo::MemoryExhausted)
-        })?;
-        // SAFETY: the box was zero-allocated, which is a valid initial value for Box<[u8]>
-        let bytes = unsafe { bytes.assume_init() };
+        let align_usize: usize = align.bytes().try_into().unwrap();
+        let layout = std::alloc::Layout::from_size_align(size.bytes_usize(), align_usize).unwrap();
+        let vec_align = unsafe {
+            // https://doc.rust-lang.org/nightly/std/alloc/trait.GlobalAlloc.html#tymethod.alloc
+            // std::alloc::alloc returns null to indicate an allocation failure: 
+            // "Returning a null pointer indicates that either memory is exhausted 
+            // or layout does not meet this allocator’s size or alignment constraints."
+            let buf = std::alloc::alloc(layout);
+            // Handle allocation failure.
+            if buf.is_null() {
+                if panic_on_fail {
+                    panic!("Allocation::uninit called with panic_on_fail had allocation failure")
+                }
+                ty::tls::with(|tcx| {
+                    tcx.sess.delay_span_bug(DUMMY_SP, "exhausted memory during interpretation")
+                });
+                Err(InterpError::ResourceExhaustion(ResourceExhaustionInfo::MemoryExhausted))?
+            } 
+            Vec::from_raw_parts(buf as *mut u8, size.bytes_usize(), size.bytes_usize())
+        };
+
+        let bytes = vec_align.into_boxed_slice();
+        assert!(bytes.as_ptr() as u64 % align.bytes() == 0);
         Ok(Allocation {
             bytes,
             relocations: Relocations::new(),
@@ -265,7 +284,17 @@ impl Allocation {
         mut adjust_ptr: impl FnMut(Pointer<AllocId>) -> Result<Pointer<Prov>, Err>,
     ) -> Result<Allocation<Prov, Extra>, Err> {
         // Compute new pointer provenance, which also adjusts the bytes.
-        let mut bytes = self.bytes;
+        // Realign the pointer
+        let align_usize: usize = self.align.bytes().try_into().unwrap();
+        let layout = std::alloc::Layout::from_size_align(self.bytes.len(), align_usize).unwrap();
+        let mut bytes = unsafe {
+            let buf = std::alloc::alloc(layout);
+            let mut boxed = Box::<[MaybeUninit<u8>]>::from_raw(std::slice::from_raw_parts_mut(buf as *mut MaybeUninit<u8>, self.bytes.len()));
+            MaybeUninit::write_slice(&mut boxed, &self.bytes);
+            boxed.assume_init()
+        };
+        assert!(bytes.as_ptr() as usize % align_usize == 0);
+
         let mut new_relocations = Vec::with_capacity(self.relocations.0.len());
         let ptr_size = cx.data_layout().pointer_size.bytes_usize();
         let endian = cx.data_layout().endian;
@@ -278,6 +307,8 @@ impl Allocation {
             write_target_uint(endian, ptr_bytes, ptr_offset.bytes().into()).unwrap();
             new_relocations.push((offset, ptr_prov));
         }
+        assert!(bytes.as_ptr() as u64 % self.align.bytes() == 0);
+
         // Create allocation.
         Ok(Allocation {
             bytes,
@@ -321,6 +352,11 @@ impl<Prov, Extra> Allocation<Prov, Extra> {
 
 /// Byte accessors.
 impl<Prov: Provenance, Extra> Allocation<Prov, Extra> {
+    /// Get the pointer of the [u8] of bytes.
+    pub fn get_bytes_addr(&self) -> Size {
+        Size::from_bytes(self.bytes.as_ptr() as u64)
+    }
+
     /// This is the entirely abstraction-violating way to just grab the raw bytes without
     /// caring about relocations. It just deduplicates some code between `read_scalar`
     /// and `get_bytes_internal`.