make it more clear which functions create fresh AllocId

RalfJung · RalfJung · commit 316396230505 · 2023-09-12T08:42:36.000+02:00
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -259,7 +259,7 @@ fn pointer_for_allocation<'tcx>(
     fx: &mut FunctionCx<'_, '_, 'tcx>,
     alloc: ConstAllocation<'tcx>,
 ) -> crate::pointer::Pointer {
-    let alloc_id = fx.tcx.create_memory_alloc(alloc);
+    let alloc_id = fx.tcx.reserve_and_set_memory_alloc(alloc);
     let data_id = data_id_for_alloc_id(
         &mut fx.constants_cx,
         &mut *fx.module,
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -84,7 +84,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         )
                         .ok_or_else(|| err_inval!(TooGeneric))?;
 
-                        let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));
+                        let fn_ptr = self.fn_ptr(FnVal::Instance(instance));
                         self.write_pointer(fn_ptr, dest)?;
                     }
                     _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
@@ -116,7 +116,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                             ty::ClosureKind::FnOnce,
                         )
                         .ok_or_else(|| err_inval!(TooGeneric))?;
-                        let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));
+                        let fn_ptr = self.fn_ptr(FnVal::Instance(instance));
                         self.write_pointer(fn_ptr, dest)?;
                     }
                     _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -57,7 +57,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             let path = crate::util::type_name(tcx, tp_ty);
             let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());
             let alloc = tcx.mk_const_alloc(alloc);
-            let alloc_id = tcx.create_memory_alloc(alloc);
+            let alloc_id = tcx.reserve_and_set_memory_alloc(alloc);
             ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: alloc.inner().len() }
         }
         sym::needs_drop => {
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -552,7 +552,7 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {
         def_id: DefId,
     ) -> InterpResult<$tcx, Pointer> {
         // Use the `AllocId` associated with the `DefId`. Any actual *access* will fail.
-        Ok(Pointer::new(ecx.tcx.create_static_alloc(def_id), Size::ZERO))
+        Ok(Pointer::new(ecx.tcx.reserve_and_set_static_alloc(def_id), Size::ZERO))
     }
 
     #[inline(always)]
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -176,12 +176,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         M::adjust_alloc_base_pointer(self, ptr)
     }
 
-    pub fn create_fn_alloc_ptr(
-        &mut self,
-        fn_val: FnVal<'tcx, M::ExtraFnVal>,
-    ) -> Pointer<M::Provenance> {
+    pub fn fn_ptr(&mut self, fn_val: FnVal<'tcx, M::ExtraFnVal>) -> Pointer<M::Provenance> {
         let id = match fn_val {
-            FnVal::Instance(instance) => self.tcx.create_fn_alloc(instance),
+            FnVal::Instance(instance) => self.tcx.reserve_and_set_fn_alloc(instance),
             FnVal::Other(extra) => {
                 // FIXME(RalfJung): Should we have a cache here?
                 let id = self.tcx.reserve_alloc_id();
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -27,7 +27,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         ensure_monomorphic_enough(*self.tcx, ty)?;
         ensure_monomorphic_enough(*self.tcx, poly_trait_ref)?;
 
-        let vtable_symbolic_allocation = self.tcx.create_vtable_alloc(ty, poly_trait_ref);
+        let vtable_symbolic_allocation = self.tcx.reserve_and_set_vtable_alloc(ty, poly_trait_ref);
         let vtable_ptr = self.global_base_pointer(Pointer::from(vtable_symbolic_allocation))?;
         Ok(vtable_ptr.into())
     }
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -389,7 +389,7 @@ impl<'s> AllocDecodingSession<'s> {
                     trace!("creating fn alloc ID");
                     let instance = ty::Instance::decode(decoder);
                     trace!("decoded fn alloc instance: {:?}", instance);
-                    let alloc_id = decoder.interner().create_fn_alloc(instance);
+                    let alloc_id = decoder.interner().reserve_and_set_fn_alloc(instance);
                     alloc_id
                 }
                 AllocDiscriminant::VTable => {
@@ -399,15 +399,16 @@ impl<'s> AllocDecodingSession<'s> {
                     let poly_trait_ref =
                         <Option<ty::PolyExistentialTraitRef<'_>> as Decodable<D>>::decode(decoder);
                     trace!("decoded vtable alloc instance: {ty:?}, {poly_trait_ref:?}");
-                    let alloc_id = decoder.interner().create_vtable_alloc(ty, poly_trait_ref);
+                    let alloc_id =
+                        decoder.interner().reserve_and_set_vtable_alloc(ty, poly_trait_ref);
                     alloc_id
                 }
                 AllocDiscriminant::Static => {
                     assert!(alloc_id.is_none());
                     trace!("creating extern static alloc ID");
                     let did = <DefId as Decodable<D>>::decode(decoder);
                     trace!("decoded static def-ID: {:?}", did);
-                    let alloc_id = decoder.interner().create_static_alloc(did);
+                    let alloc_id = decoder.interner().reserve_and_set_static_alloc(did);
                     alloc_id
                 }
             }
@@ -544,13 +545,13 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Generates an `AllocId` for a static or return a cached one in case this function has been
     /// called on the same static before.
-    pub fn create_static_alloc(self, static_id: DefId) -> AllocId {
+    pub fn reserve_and_set_static_alloc(self, static_id: DefId) -> AllocId {
         self.reserve_and_set_dedup(GlobalAlloc::Static(static_id))
     }
 
     /// Generates an `AllocId` for a function. Depending on the function type,
     /// this might get deduplicated or assigned a new ID each time.
-    pub fn create_fn_alloc(self, instance: Instance<'tcx>) -> AllocId {
+    pub fn reserve_and_set_fn_alloc(self, instance: Instance<'tcx>) -> AllocId {
         // Functions cannot be identified by pointers, as asm-equal functions can get deduplicated
         // by the linker (we set the "unnamed_addr" attribute for LLVM) and functions can be
         // duplicated across crates.
@@ -575,7 +576,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     /// Generates an `AllocId` for a (symbolic, not-reified) vtable. Will get deduplicated.
-    pub fn create_vtable_alloc(
+    pub fn reserve_and_set_vtable_alloc(
         self,
         ty: Ty<'tcx>,
         poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
@@ -588,7 +589,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Statics with identical content will still point to the same `Allocation`, i.e.,
     /// their data will be deduplicated through `Allocation` interning -- but they
     /// are different places in memory and as such need different IDs.
-    pub fn create_memory_alloc(self, mem: ConstAllocation<'tcx>) -> AllocId {
+    pub fn reserve_and_set_memory_alloc(self, mem: ConstAllocation<'tcx>) -> AllocId {
         let id = self.reserve_alloc_id();
         self.set_alloc_id_memory(id, mem);
         id
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -647,7 +647,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // Create an allocation that just contains these bytes.
         let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes);
         let alloc = self.mk_const_alloc(alloc);
-        self.create_memory_alloc(alloc)
+        self.reserve_and_set_memory_alloc(alloc)
     }
 
     /// Returns a range of the start/end indices specified with the
diff --git a/compiler/rustc_middle/src/ty/vtable.rs b/compiler/rustc_middle/src/ty/vtable.rs
@@ -84,7 +84,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
         let scalar = match entry {
             VtblEntry::MetadataDropInPlace => {
                 let instance = ty::Instance::resolve_drop_in_place(tcx, ty);
-                let fn_alloc_id = tcx.create_fn_alloc(instance);
+                let fn_alloc_id = tcx.reserve_and_set_fn_alloc(instance);
                 let fn_ptr = Pointer::from(fn_alloc_id);
                 Scalar::from_pointer(fn_ptr, &tcx)
             }
@@ -94,7 +94,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
             VtblEntry::Method(instance) => {
                 // Prepare the fn ptr we write into the vtable.
                 let instance = instance.polymorphize(tcx);
-                let fn_alloc_id = tcx.create_fn_alloc(instance);
+                let fn_alloc_id = tcx.reserve_and_set_fn_alloc(instance);
                 let fn_ptr = Pointer::from(fn_alloc_id);
                 Scalar::from_pointer(fn_ptr, &tcx)
             }
@@ -112,5 +112,5 @@ pub(super) fn vtable_allocation_provider<'tcx>(
     }
 
     vtable.mutability = Mutability::Not;
-    tcx.create_memory_alloc(tcx.mk_const_alloc(vtable))
+    tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(vtable))
 }
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -133,15 +133,15 @@ fn lit_to_mir_constant<'tcx>(
             let s = s.as_str();
             let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());
             let allocation = tcx.mk_const_alloc(allocation);
-            let alloc_id = tcx.create_memory_alloc(allocation);
+            let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);
             ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: s.len() }
         }
         (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 = tcx.mk_const_alloc(allocation);
-            let alloc_id = tcx.create_memory_alloc(allocation);
+            let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);
             ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: data.len() }
         }
         (ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_array() => {
@@ -152,7 +152,7 @@ fn lit_to_mir_constant<'tcx>(
         {
             let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8]);
             let allocation = tcx.mk_const_alloc(allocation);
-            let alloc_id = tcx.create_memory_alloc(allocation);
+            let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);
             ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: data.len() }
         }
         (ast::LitKind::Byte(n), ty::Uint(ty::UintTy::U8)) => {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -950,7 +950,7 @@ impl<'tcx> Cx<'tcx> {
                 let kind = if self.tcx.is_thread_local_static(id) {
                     ExprKind::ThreadLocalRef(id)
                 } else {
-                    let alloc_id = self.tcx.create_static_alloc(id);
+                    let alloc_id = self.tcx.reserve_and_set_static_alloc(id);
                     ExprKind::StaticRef { alloc_id, ty, def_id: id }
                 };
                 ExprKind::Deref {
diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -114,7 +114,7 @@ impl EnumSizeOpt {
             tcx.data_layout.ptr_sized_integer().align(&tcx.data_layout).abi,
             Mutability::Not,
         );
-        let alloc = tcx.create_memory_alloc(tcx.mk_const_alloc(alloc));
+        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)))
     }
     fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
@@ -382,7 +382,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
             .unwrap()
             .unwrap();
 
-            let main_ptr = ecx.create_fn_alloc_ptr(FnVal::Instance(entry_instance));
+            let main_ptr = ecx.fn_ptr(FnVal::Instance(entry_instance));
 
             // Inlining of `DEFAULT` from
             // https://github.com/rust-lang/rust/blob/master/compiler/rustc_session/src/config/sigpipe.rs.
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
@@ -711,7 +711,7 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
                 let layout = this.machine.layouts.const_raw_ptr;
                 let dlsym = Dlsym::from_str("signal".as_bytes(), &this.tcx.sess.target.os)?
                     .expect("`signal` must be an actual dlsym on android");
-                let ptr = this.create_fn_alloc_ptr(FnVal::Other(dlsym));
+                let ptr = this.fn_ptr(FnVal::Other(dlsym));
                 let val = ImmTy::from_scalar(Scalar::from_pointer(ptr, this), layout);
                 Self::alloc_extern_static(this, "signal", val)?;
                 // A couple zero-initialized pointer-sized extern statics.
diff --git a/src/tools/miri/src/shims/backtrace.rs b/src/tools/miri/src/shims/backtrace.rs
@@ -63,7 +63,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // to reconstruct the needed frame information in `handle_miri_resolve_frame`.
                 // Note that we never actually read or write anything from/to this pointer -
                 // all of the data is represented by the pointer value itself.
-                let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(instance));
+                let fn_ptr = this.fn_ptr(FnVal::Instance(instance));
                 fn_ptr.wrapping_offset(Size::from_bytes(pos.0), this)
             })
             .collect();
@@ -159,7 +159,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
         // Reconstruct the original function pointer,
         // which we pass to user code.
-        let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(fn_instance));
+        let fn_ptr = this.fn_ptr(FnVal::Instance(fn_instance));
 
         let num_fields = dest.layout.fields.count();
 
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -232,7 +232,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 let symbol = this.read_pointer(symbol)?;
                 let symbol_name = this.read_c_str(symbol)?;
                 if let Some(dlsym) = Dlsym::from_str(symbol_name, &this.tcx.sess.target.os)? {
-                    let ptr = this.create_fn_alloc_ptr(FnVal::Other(dlsym));
+                    let ptr = this.fn_ptr(FnVal::Other(dlsym));
                     this.write_pointer(ptr, dest)?;
                 } else {
                     this.write_null(dest)?;
diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -335,7 +335,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 this.read_target_isize(hModule)?;
                 let name = this.read_c_str(this.read_pointer(lpProcName)?)?;
                 if let Some(dlsym) = Dlsym::from_str(name, &this.tcx.sess.target.os)? {
-                    let ptr = this.create_fn_alloc_ptr(FnVal::Other(dlsym));
+                    let ptr = this.fn_ptr(FnVal::Other(dlsym));
                     this.write_pointer(ptr, dest)?;
                 } else {
                     this.write_null(dest)?;

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`84`	`84`	`)`
`85`	`85`	`.ok_or_else(\|\| err_inval!(TooGeneric))?;`
`86`	`86`
`87`		`- let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));`
	`87`	`+ let fn_ptr = self.fn_ptr(FnVal::Instance(instance));`
`88`	`88`	`self.write_pointer(fn_ptr, dest)?;`
`89`	`89`	`}`
`90`	`90`	`_ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),`
`@@ -116,7 +116,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`116`	`116`	`ty::ClosureKind::FnOnce,`
`117`	`117`	`)`
`118`	`118`	`.ok_or_else(\|\| err_inval!(TooGeneric))?;`
`119`		`- let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));`
	`119`	`+ let fn_ptr = self.fn_ptr(FnVal::Instance(instance));`
`120`	`120`	`self.write_pointer(fn_ptr, dest)?;`
`121`	`121`	`}`
`122`	`122`	`_ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(`
`57`	`57`	`let path = crate::util::type_name(tcx, tp_ty);`
`58`	`58`	`let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());`
`59`	`59`	`let alloc = tcx.mk_const_alloc(alloc);`
`60`		`- let alloc_id = tcx.create_memory_alloc(alloc);`
	`60`	`+ let alloc_id = tcx.reserve_and_set_memory_alloc(alloc);`
`61`	`61`	`ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: alloc.inner().len() }`
`62`	`62`	`}`
`63`	`63`	`sym::needs_drop => {`
Original file line number	Diff line number	Diff line change
`@@ -552,7 +552,7 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {`
`552`	`552`	`def_id: DefId,`
`553`	`553`	`) -> InterpResult<$tcx, Pointer> {`
`554`	`554`	// Use the `AllocId` associated with the `DefId`. Any actual access will fail.
`555`		`- Ok(Pointer::new(ecx.tcx.create_static_alloc(def_id), Size::ZERO))`
	`555`	`+ Ok(Pointer::new(ecx.tcx.reserve_and_set_static_alloc(def_id), Size::ZERO))`
`556`	`556`	`}`
`557`	`557`
`558`	`558`	`#[inline(always)]`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`27`	`27`	`ensure_monomorphic_enough(*self.tcx, ty)?;`
`28`	`28`	`ensure_monomorphic_enough(*self.tcx, poly_trait_ref)?;`
`29`	`29`
`30`		`- let vtable_symbolic_allocation = self.tcx.create_vtable_alloc(ty, poly_trait_ref);`
	`30`	`+ let vtable_symbolic_allocation = self.tcx.reserve_and_set_vtable_alloc(ty, poly_trait_ref);`
`31`	`31`	`let vtable_ptr = self.global_base_pointer(Pointer::from(vtable_symbolic_allocation))?;`
`32`	`32`	`Ok(vtable_ptr.into())`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -647,7 +647,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`647`	`647`	`// Create an allocation that just contains these bytes.`
`648`	`648`	`let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes);`
`649`	`649`	`let alloc = self.mk_const_alloc(alloc);`
`650`		`- self.create_memory_alloc(alloc)`
	`650`	`+ self.reserve_and_set_memory_alloc(alloc)`
`651`	`651`	`}`
`652`	`652`
`653`	`653`	`/// Returns a range of the start/end indices specified with the`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(`
`84`	`84`	`let scalar = match entry {`
`85`	`85`	`VtblEntry::MetadataDropInPlace => {`
`86`	`86`	`let instance = ty::Instance::resolve_drop_in_place(tcx, ty);`
`87`		`- let fn_alloc_id = tcx.create_fn_alloc(instance);`
	`87`	`+ let fn_alloc_id = tcx.reserve_and_set_fn_alloc(instance);`
`88`	`88`	`let fn_ptr = Pointer::from(fn_alloc_id);`
`89`	`89`	`Scalar::from_pointer(fn_ptr, &tcx)`
`90`	`90`	`}`
`@@ -94,7 +94,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(`
`94`	`94`	`VtblEntry::Method(instance) => {`
`95`	`95`	`// Prepare the fn ptr we write into the vtable.`
`96`	`96`	`let instance = instance.polymorphize(tcx);`
`97`		`- let fn_alloc_id = tcx.create_fn_alloc(instance);`
	`97`	`+ let fn_alloc_id = tcx.reserve_and_set_fn_alloc(instance);`
`98`	`98`	`let fn_ptr = Pointer::from(fn_alloc_id);`
`99`	`99`	`Scalar::from_pointer(fn_ptr, &tcx)`
`100`	`100`	`}`
`@@ -112,5 +112,5 @@ pub(super) fn vtable_allocation_provider<'tcx>(`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`vtable.mutability = Mutability::Not;`
`115`		`- tcx.create_memory_alloc(tcx.mk_const_alloc(vtable))`
	`115`	`+ tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(vtable))`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,15 +133,15 @@ fn lit_to_mir_constant<'tcx>(`
`133`	`133`	`let s = s.as_str();`
`134`	`134`	`let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());`
`135`	`135`	`let allocation = tcx.mk_const_alloc(allocation);`
`136`		`- let alloc_id = tcx.create_memory_alloc(allocation);`
	`136`	`+ let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);`
`137`	`137`	`ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: s.len() }`
`138`	`138`	`}`
`139`	`139`	`(ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _))`
`140`	`140`	`if matches!(inner_ty.kind(), ty::Slice(_)) =>`
`141`	`141`	`{`
`142`	`142`	`let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8]);`
`143`	`143`	`let allocation = tcx.mk_const_alloc(allocation);`
`144`		`- let alloc_id = tcx.create_memory_alloc(allocation);`
	`144`	`+ let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);`
`145`	`145`	`ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: data.len() }`
`146`	`146`	`}`
`147`	`147`	`(ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_array() => {`
`@@ -152,7 +152,7 @@ fn lit_to_mir_constant<'tcx>(`
`152`	`152`	`{`
`153`	`153`	`let allocation = Allocation::from_bytes_byte_aligned_immutable(data as &[u8]);`
`154`	`154`	`let allocation = tcx.mk_const_alloc(allocation);`
`155`		`- let alloc_id = tcx.create_memory_alloc(allocation);`
	`155`	`+ let alloc_id = tcx.reserve_and_set_memory_alloc(allocation);`
`156`	`156`	`ConstValue::Slice { alloc_id: Some(alloc_id), start: 0, end: data.len() }`
`157`	`157`	`}`
`158`	`158`	`(ast::LitKind::Byte(n), ty::Uint(ty::UintTy::U8)) => {`