Remove MemoryKind check in allocate_str

Author: adwinwhite

compiler/rustc_const_eval/src/interpret/place.rs

@@ -995,6 +995,7 @@ where
     }
 
     /// Returns a wide MPlace of type `str` to a new 1-aligned allocation.
+    /// Immutable strings are deduplicated and stored in global memory.
     pub fn allocate_str(
         &mut self,
         str: &str,
@@ -1004,11 +1005,9 @@ where
         let tcx = self.tcx.tcx;
 
         // Use cache for immutable strings.
-        let ptr = if mutbl.is_not()
-            && matches!(kind, MemoryKind::CallerLocation | MemoryKind::Machine(_))
-        {
-            // Same id for cached allocations.
-            let id = tcx.allocate_bytes(str.as_bytes());
+        let ptr = if mutbl.is_not() {
+            // Use dedup'd allocation function.
+            let id = tcx.allocate_bytes_dedup(str.as_bytes());
 
             // Turn untagged "global" pointers (obtained via `tcx`) into the machine pointer to the allocation.
             M::adjust_alloc_root_pointer(&self, Pointer::from(id), Some(kind))?

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

@@ -434,6 +434,11 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Reserves a new ID *if* this allocation has not been dedup-reserved before.
     fn reserve_and_set_dedup(self, alloc: GlobalAlloc<'tcx>) -> AllocId {
         let mut alloc_map = self.alloc_map.lock();
+        if let GlobalAlloc::Memory(mem) = alloc {
+            if mem.inner().mutability.is_mut() {
+                bug!("trying to dedup-reserve mutable memory");
+            }
+        }
         if let Some(&alloc_id) = alloc_map.dedup.get(&alloc) {
             return alloc_id;
         }

compiler/rustc_middle/src/ty/context.rs

@@ -1443,7 +1443,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Allocates a read-only byte or string literal for `mir::interpret`.
     /// Returns the same `AllocId` if called again with the same bytes.
-    pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId {
+    pub fn allocate_bytes_dedup(self, bytes: &[u8]) -> interpret::AllocId {
         // 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);

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

@@ -140,7 +140,7 @@ fn lit_to_mir_constant<'tcx>(
             ConstValue::Slice { data: allocation, meta: allocation.inner().size().bytes() }
         }
         (ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_array() => {
-            let id = tcx.allocate_bytes(data);
+            let id = tcx.allocate_bytes_dedup(data);
             ConstValue::Scalar(Scalar::from_pointer(id.into(), &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)) =>