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

@@ -24,10 +24,17 @@ use super::{
 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);
+pub(crate) fn alloc_type_name<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+) -> (ConstAllocation<'tcx>, u64) {
+    let mut path = crate::util::type_name(tcx, ty);
+    let path_len = path.len().try_into().unwrap();
+    if !path.contains('\0') {
+        path.push('\0');
+    };
     let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());
-    tcx.mk_const_alloc(alloc)
+    (tcx.mk_const_alloc(alloc), path_len)
 }
 
 /// The logic for all nullary intrinsics is implemented here. These intrinsics don't get evaluated
@@ -43,8 +50,8 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
     interp_ok(match name {
         sym::type_name => {
             ensure_monomorphic_enough(tcx, tp_ty)?;
-            let alloc = alloc_type_name(tcx, tp_ty);
-            ConstValue::Slice { data: alloc, meta: alloc.inner().size().bytes() }
+            let (alloc, path_len) = alloc_type_name(tcx, tp_ty);
+            ConstValue::Slice { data: alloc, meta: path_len }
         }
         sym::needs_drop => {
             ensure_monomorphic_enough(tcx, tp_ty)?;

compiler/rustc_const_eval/src/interpret/place.rs

@@ -1019,11 +1019,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

@@ -125,9 +125,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();
-            let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());
+            let allocation = if !s.contains('\0') {
+                let mut s = s.to_owned();
+                s.push('\0');
+                Allocation::from_bytes_byte_aligned_immutable(s.as_bytes())
+            } else {
+                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() }
+            ConstValue::Slice { data: allocation, meta: s.len().try_into().unwrap() }
         }
         (ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _))
             if matches!(inner_ty.kind(), ty::Slice(_)) =>

tests/codegen/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.
 }