Nul terminate rust string literals

This allows taking advantage of the C string merging functionality of
linkers, reducing code size.

Author: bjorn3

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -25,10 +25,12 @@ 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>) -> (AllocId, u64) {
-    let path = crate::util::type_name(tcx, ty);
-    let bytes = path.into_bytes();
-    let len = bytes.len().try_into().unwrap();
-    (tcx.allocate_bytes_dedup(bytes, CTFE_ALLOC_SALT), len)
+    let mut path = crate::util::type_name(tcx, ty);
+    let path_len = path.len().try_into().unwrap();
+    if !path.contains('\0') {
+        path.push('\0');
+    };
+    (tcx.allocate_bytes_dedup(path.into_bytes(), CTFE_ALLOC_SALT), path_len)
 }
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// Generates a value of `TypeId` for `ty` in-place.

compiler/rustc_const_eval/src/interpret/place.rs

@@ -1024,11 +1024,16 @@ where
         &mut self,
         s: &str,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
-        let bytes = s.as_bytes();
-        let ptr = self.allocate_bytes_dedup(bytes)?;
+        let ptr = if !s.contains('\0') {
+            let mut bytes = s.as_bytes().to_owned();
+            bytes.push(0);
+            self.allocate_bytes_dedup(&bytes)?
+        } else {
+            self.allocate_bytes_dedup(s.as_bytes())?
+        };
 
         // Create length metadata for the string.
-        let meta = Scalar::from_target_usize(u64::try_from(bytes.len()).unwrap(), self);
+        let meta = Scalar::from_target_usize(u64::try_from(s.len()).unwrap(), self);
 
         // Get layout for Rust's str type.
         let layout = self.layout_of(self.tcx.types.str_).unwrap();

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

@@ -120,10 +120,15 @@ 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().as_bytes();
-            let len = s.len();
-            let allocation = tcx.allocate_bytes_dedup(s, CTFE_ALLOC_SALT);
-            ConstValue::Slice { alloc_id: allocation, meta: len.try_into().unwrap() }
+            let s = s.as_str();
+            let allocation = if !s.contains('\0') {
+                let mut s = s.to_owned();
+                s.push('\0');
+                tcx.allocate_bytes_dedup(s.as_bytes(), CTFE_ALLOC_SALT)
+            } else {
+                tcx.allocate_bytes_dedup(s.as_bytes(), CTFE_ALLOC_SALT)
+            };
+            ConstValue::Slice { alloc_id: allocation, meta: s.len().try_into().unwrap() }
         }
         (ast::LitKind::ByteStr(byte_sym, _), ty::Ref(_, inner_ty, _))
             if matches!(inner_ty.kind(), ty::Slice(_)) =>

tests/codegen-llvm/remap_path_prefix/main.rs

@@ -12,7 +12,7 @@ mod aux_mod;
 include!("aux_mod.rs");
 
 // Here we check that the expansion of the file!() macro is mapped.
-// CHECK: @alloc_5761061597a97f66e13ef2ff92712c4b = private unnamed_addr constant [34 x i8] c"/the/src/remap_path_prefix/main.rs"
+// CHECK: @alloc_4079a2e7607f89f86df6b8a72ba0dd06 = private unnamed_addr constant [35 x i8] c"/the/src/remap_path_prefix/main.rs\00"
 pub static FILE_PATH: &'static str = file!();
 
 fn main() {

tests/mir-opt/const_allocation.main.GVN.after.32bit.mir

@@ -33,27 +33,27 @@ ALLOC2 (size: 16, align: 4) {
     ╾ALLOC4<imm>╼ 03 00 00 00 ╾ALLOC5<imm>╼ 03 00 00 00 │ ╾──╼....╾──╼....
 }
 
-ALLOC4 (size: 3, align: 1) {
-    66 6f 6f                                        │ foo
+ALLOC4 (size: 4, align: 1) {
+    66 6f 6f 00                                     │ foo.
 }
 
-ALLOC5 (size: 3, align: 1) {
-    62 61 72                                        │ bar
+ALLOC5 (size: 4, align: 1) {
+    62 61 72 00                                     │ bar.
 }
 
 ALLOC3 (size: 24, align: 4) {
     0x00 │ ╾ALLOC6<imm>╼ 03 00 00 00 ╾ALLOC7<imm>╼ 03 00 00 00 │ ╾──╼....╾──╼....
     0x10 │ ╾ALLOC8<imm>╼ 04 00 00 00                         │ ╾──╼....
 }
 
-ALLOC6 (size: 3, align: 1) {
-    6d 65 68                                        │ meh
+ALLOC6 (size: 4, align: 1) {
+    6d 65 68 00                                     │ meh.
 }
 
-ALLOC7 (size: 3, align: 1) {
-    6d 6f 70                                        │ mop
+ALLOC7 (size: 4, align: 1) {
+    6d 6f 70 00                                     │ mop.
 }
 
-ALLOC8 (size: 4, align: 1) {
-    6d c3 b6 70                                     │ m..p
+ALLOC8 (size: 5, align: 1) {
+    6d c3 b6 70 00                                  │ m..p.
 }

tests/mir-opt/const_allocation.main.GVN.after.64bit.mir

@@ -36,12 +36,12 @@ ALLOC2 (size: 32, align: 8) {
     0x10 │ ╾ALLOC5<imm>╼ 03 00 00 00 00 00 00 00 │ ╾──────╼........
 }
 
-ALLOC4 (size: 3, align: 1) {
-    66 6f 6f                                        │ foo
+ALLOC4 (size: 4, align: 1) {
+    66 6f 6f 00                                     │ foo.
 }
 
-ALLOC5 (size: 3, align: 1) {
-    62 61 72                                        │ bar
+ALLOC5 (size: 4, align: 1) {
+    62 61 72 00                                     │ bar.
 }
 
 ALLOC3 (size: 48, align: 8) {
@@ -50,14 +50,14 @@ ALLOC3 (size: 48, align: 8) {
     0x20 │ ╾ALLOC8<imm>╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
 }
 
-ALLOC6 (size: 3, align: 1) {
-    6d 65 68                                        │ meh
+ALLOC6 (size: 4, align: 1) {
+    6d 65 68 00                                     │ meh.
 }
 
-ALLOC7 (size: 3, align: 1) {
-    6d 6f 70                                        │ mop
+ALLOC7 (size: 4, align: 1) {
+    6d 6f 70 00                                     │ mop.
 }
 
-ALLOC8 (size: 4, align: 1) {
-    6d c3 b6 70                                     │ m..p
+ALLOC8 (size: 5, align: 1) {
+    6d c3 b6 70 00                                  │ m..p.
 }

tests/ui-fulldeps/rustc_public/check_allocation.rs

@@ -77,11 +77,12 @@ fn check_bar(item: CrateItem) {
 
     let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
     let GlobalAlloc::Memory(allocation) = GlobalAlloc::from(alloc_id_0) else { unreachable!() };
-    assert_eq!(allocation.bytes.len(), 3);
+    assert_eq!(allocation.bytes.len(), 4);
     assert_eq!(allocation.bytes[0].unwrap(), Char::CapitalB.to_u8());
     assert_eq!(allocation.bytes[1].unwrap(), Char::SmallA.to_u8());
     assert_eq!(allocation.bytes[2].unwrap(), Char::SmallR.to_u8());
-    assert_eq!(std::str::from_utf8(&allocation.raw_bytes().unwrap()), Ok("Bar"));
+    assert_eq!(allocation.bytes[3].unwrap(), Char::Null.to_u8());
+    assert_eq!(std::str::from_utf8(&allocation.raw_bytes().unwrap()), Ok("Bar\0"));
 }
 
 /// Check the allocation data for static `C_STR`.

tests/ui-fulldeps/rustc_public/check_transform.rs

@@ -37,7 +37,7 @@ fn test_transform() -> ControlFlow<()> {
     let target_fn = *get_item(&items, (ItemKind::Fn, "dummy")).unwrap();
     let instance = Instance::try_from(target_fn).unwrap();
     let body = instance.body().unwrap();
-    check_msg(&body, "oops");
+    check_msg(&body, "oops\0");
 
     let new_msg = "new panic message";
     let new_body = change_panic_msg(body, new_msg);