debuginfo: Use inlinable_string crate to avoid allocations for small strings.

Author: michaelwoerister

Cargo.lock

@@ -1768,6 +1768,12 @@ dependencies = [
  "unindent",
 ]
 
+[[package]]
+name = "inlinable_string"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
+
 [[package]]
 name = "installer"
 version = "0.0.0"
@@ -3537,6 +3543,7 @@ version = "0.0.0"
 dependencies = [
  "bitflags",
  "cstr",
+ "inlinable_string",
  "libc",
  "libloading",
  "measureme 10.0.0",
@@ -3633,6 +3640,7 @@ dependencies = [
  "cfg-if 0.1.10",
  "ena",
  "indexmap",
+ "inlinable_string",
  "jobserver",
  "libc",
  "measureme 10.0.0",

compiler/rustc_codegen_llvm/Cargo.toml

@@ -10,6 +10,7 @@ doctest = false
 [dependencies]
 bitflags = "1.0"
 cstr = "0.2"
+inlinable_string = { version = "0.1", features = ["nightly"] }
 libc = "0.2"
 libloading = "0.7.1"
 measureme = "10.0.0"

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -20,9 +20,11 @@ use crate::llvm::debuginfo::{
 use crate::value::Value;
 
 use cstr::cstr;
+use inlinable_string::InlinableString;
 use rustc_codegen_ssa::debuginfo::type_names::cpp_like_debuginfo;
 use rustc_codegen_ssa::debuginfo::type_names::VTableNameKind;
 use rustc_codegen_ssa::traits::*;
+use rustc_data_structures::base_n;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_fs_util::path_to_c_string;
 use rustc_hir::def::CtorKind;
@@ -93,8 +95,23 @@ pub const UNKNOWN_COLUMN_NUMBER: c_uint = 0;
 
 pub const NO_SCOPE_METADATA: Option<&DIScope> = None;
 
+/// Same as format!() but produces an InlinableString to avoid
+/// unnecessary memory allocations.
+macro_rules! format_inline {
+    ($($tokens:expr),*) => {
+        {
+            use inlinable_string::StringExt;
+            let mut string = inlinable_string::InlinableString::new();
+            write!(&mut string, $($tokens),*).unwrap();
+            string
+        }
+    };
+}
+
 mod unique_type_id {
+    use inlinable_string::InlinableString;
     use rustc_data_structures::{
+        base_n,
         fingerprint::Fingerprint,
         stable_hasher::{HashStable, NodeIdHashingMode, StableHasher},
     };
@@ -163,15 +180,16 @@ mod unique_type_id {
             UniqueTypeId::VTableTy(self_type, implemented_trait, HiddenZst { _inaccessible: () })
         }
 
-        pub fn to_string(&self, tcx: TyCtxt<'tcx>) -> String {
+        pub fn to_string(&self, tcx: TyCtxt<'tcx>) -> InlinableString {
             let mut hasher = StableHasher::new();
             let mut hcx = tcx.create_stable_hashing_context();
             hcx.while_hashing_spans(false, |hcx| {
                 hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
                     self.hash_stable(hcx, &mut hasher);
                 });
             });
-            hasher.finish::<Fingerprint>().to_hex()
+            let (low, high) = hasher.finish::<Fingerprint>().as_value();
+            base_n::encode((low as u128) | ((high as u128) << 64), base_n::MAX_BASE)
         }
     }
 }
@@ -884,7 +902,7 @@ fn foreign_type_metadata<'ll, 'tcx>(
 
 fn param_type_metadata<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
     debug!("param_type_metadata: {:?}", t);
-    let name = format!("{:?}", t);
+    let name = format_inline!("{:?}", t);
     unsafe {
         llvm::LLVMRustDIBuilderCreateBasicType(
             DIB(cx),
@@ -1077,7 +1095,7 @@ struct SourceInfo<'ll> {
 /// structs or tuples) or an enum variant.
 #[derive(Debug)]
 struct MemberDescription<'ll> {
-    name: String,
+    name: InlinableString,
     type_metadata: &'ll DIType,
     offset: Size,
     size: Size,
@@ -1162,9 +1180,9 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
             .enumerate()
             .map(|(i, f)| {
                 let name = if self.variant.ctor_kind == CtorKind::Fn {
-                    format!("__{}", i)
+                    format_inline!("__{}", i)
                 } else {
-                    f.name.to_string()
+                    f.name.as_str().into()
                 };
                 let field = layout.field(cx, i);
                 MemberDescription {
@@ -1227,7 +1245,10 @@ fn prepare_struct_metadata<'ll, 'tcx>(
 /// Here are some examples:
 ///  - `name__field1__field2` when the upvar is captured by value.
 ///  - `_ref__name__field` when the upvar is captured by reference.
-fn closure_saved_names_of_captured_variables(tcx: TyCtxt<'_>, def_id: DefId) -> Vec<String> {
+fn closure_saved_names_of_captured_variables(
+    tcx: TyCtxt<'_>,
+    def_id: DefId,
+) -> Vec<InlinableString> {
     let body = tcx.optimized_mir(def_id);
 
     body.var_debug_info
@@ -1242,7 +1263,7 @@ fn closure_saved_names_of_captured_variables(tcx: TyCtxt<'_>, def_id: DefId) ->
                 _ => return None,
             };
             let prefix = if is_ref { "_ref__" } else { "" };
-            Some(prefix.to_owned() + var.name.as_str())
+            Some(format_inline!("{}{}", prefix, var.name))
         })
         .collect::<Vec<_>>()
 }
@@ -1273,7 +1294,7 @@ impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
                 let name = if let Some(names) = capture_names.as_mut() {
                     names.next().unwrap()
                 } else {
-                    format!("__{}", i)
+                    format_inline!("__{}", i)
                 };
                 MemberDescription {
                     name,
@@ -1345,7 +1366,7 @@ impl<'tcx> UnionMemberDescriptionFactory<'tcx> {
             .map(|(i, f)| {
                 let field = self.layout.field(cx, i);
                 MemberDescription {
-                    name: f.name.to_string(),
+                    name: f.name.as_str().into(),
                     type_metadata: type_metadata(cx, field.ty),
                     offset: Size::ZERO,
                     size: field.size,
@@ -1563,7 +1584,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
 
                         MemberDescription {
                             name: if fallback {
-                                format!("variant{}", i.as_u32())
+                                format_inline!("variant{}", i.as_u32())
                             } else {
                                 variant_info.variant_name()
                             },
@@ -1697,7 +1718,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
                     vec![
                         MemberDescription {
                             // Name the dataful variant so that we can identify it for natvis
-                            name: "dataful_variant".to_string(),
+                            name: "dataful_variant".into(),
                             type_metadata: variant_type_metadata,
                             offset: Size::ZERO,
                             size: self.layout.size,
@@ -1762,7 +1783,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
 struct VariantMemberDescriptionFactory<'tcx> {
     /// Cloned from the `layout::Struct` describing the variant.
     offsets: Vec<Size>,
-    args: Vec<(String, Ty<'tcx>)>,
+    args: Vec<(InlinableString, Ty<'tcx>)>,
 }
 
 impl<'tcx> VariantMemberDescriptionFactory<'tcx> {
@@ -1776,7 +1797,7 @@ impl<'tcx> VariantMemberDescriptionFactory<'tcx> {
             .map(|(i, &(ref name, ty))| {
                 let (size, align) = cx.size_and_align_of(ty);
                 MemberDescription {
-                    name: name.to_string(),
+                    name: name.clone(),
                     type_metadata: type_metadata(cx, ty),
                     offset: self.offsets[i],
                     size,
@@ -1819,20 +1840,20 @@ impl<'tcx> VariantInfo<'_, 'tcx> {
         }
     }
 
-    fn variant_name(&self) -> String {
+    fn variant_name(&self) -> InlinableString {
         match self {
-            VariantInfo::Adt(variant, _) => variant.name.to_string(),
+            VariantInfo::Adt(variant, _) => variant.name.as_str().into(),
             VariantInfo::Generator { variant_index, .. } => {
                 // Since GDB currently prints out the raw discriminant along
                 // with every variant, make each variant name be just the value
                 // of the discriminant. The struct name for the variant includes
                 // the actual variant description.
-                format!("{}", variant_index.as_usize())
+                base_n::encode(variant_index.as_usize() as u128, 10)
             }
         }
     }
 
-    fn field_name(&self, i: usize) -> String {
+    fn field_name(&self, i: usize) -> InlinableString {
         let field_name = match *self {
             VariantInfo::Adt(variant, _) if variant.ctor_kind != CtorKind::Fn => {
                 Some(variant.fields[i].name)
@@ -1848,7 +1869,7 @@ impl<'tcx> VariantInfo<'_, 'tcx> {
             }
             _ => None,
         };
-        field_name.map(|name| name.to_string()).unwrap_or_else(|| format!("__{}", i))
+        field_name.map(|name| name.as_str().into()).unwrap_or_else(|| format_inline!("__{}", i))
     }
 
     fn source_info<'ll>(&self, cx: &CodegenCx<'ll, 'tcx>) -> Option<SourceInfo<'ll>> {
@@ -2532,19 +2553,19 @@ fn vtable_type_metadata<'ll, 'tcx>(
         .filter_map(|(index, vtable_entry)| {
             let (field_name, field_type) = match vtable_entry {
                 ty::VtblEntry::MetadataDropInPlace => {
-                    ("drop_in_place".to_string(), void_pointer_type_debuginfo)
+                    ("drop_in_place".into(), void_pointer_type_debuginfo)
                 }
                 ty::VtblEntry::Method(_) => {
                     // Note: This code does not try to give a proper name to each method
                     //       because their might be multiple methods with the same name
                     //       (coming from different traits).
-                    (format!("__method{}", index), void_pointer_type_debuginfo)
+                    (format_inline!("__method{}", index), void_pointer_type_debuginfo)
                 }
                 ty::VtblEntry::TraitVPtr(_) => {
-                    (format!("__super_trait_ptr{}", index), void_pointer_type_debuginfo)
+                    (format_inline!("__super_trait_ptr{}", index), void_pointer_type_debuginfo)
                 }
-                ty::VtblEntry::MetadataAlign => ("align".to_string(), usize_debuginfo),
-                ty::VtblEntry::MetadataSize => ("size".to_string(), usize_debuginfo),
+                ty::VtblEntry::MetadataAlign => ("align".into(), usize_debuginfo),
+                ty::VtblEntry::MetadataSize => ("size".into(), usize_debuginfo),
                 ty::VtblEntry::Vacant => return None,
             };
 

compiler/rustc_data_structures/Cargo.toml

@@ -27,6 +27,7 @@ measureme = "10.0.0"
 libc = "0.2"
 stacker = "0.1.14"
 tempfile = "3.2"
+inlinable_string = { version = "0.1", features = ["nightly"] }
 
 [dependencies.parking_lot]
 version = "0.11"

compiler/rustc_data_structures/src/base_n.rs

@@ -2,6 +2,8 @@
 /// Bases up to and including 36 can be used for case-insensitive things.
 use std::str;
 
+use inlinable_string::{InlinableString, StringExt};
+
 #[cfg(test)]
 mod tests;
 
@@ -13,7 +15,7 @@ const BASE_64: &[u8; MAX_BASE as usize] =
     b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@$";
 
 #[inline]
-pub fn push_str(mut n: u128, base: usize, output: &mut String) {
+pub fn push_str<'a>(mut n: u128, base: usize, output: &mut impl StringExt<'a>) {
     debug_assert!(base >= 2 && base <= MAX_BASE);
     let mut s = [0u8; 128];
     let mut index = 0;
@@ -35,8 +37,8 @@ pub fn push_str(mut n: u128, base: usize, output: &mut String) {
 }
 
 #[inline]
-pub fn encode(n: u128, base: usize) -> String {
-    let mut s = String::new();
+pub fn encode(n: u128, base: usize) -> InlinableString {
+    let mut s = InlinableString::new();
     push_str(n, base, &mut s);
     s
 }

compiler/rustc_incremental/src/persist/fs.rs

@@ -640,7 +640,7 @@ fn extract_timestamp_from_session_dir(directory_name: &str) -> Result<SystemTime
 fn timestamp_to_string(timestamp: SystemTime) -> String {
     let duration = timestamp.duration_since(UNIX_EPOCH).unwrap();
     let micros = duration.as_secs() * 1_000_000 + (duration.subsec_nanos() as u64) / 1000;
-    base_n::encode(micros as u128, INT_ENCODE_BASE)
+    base_n::encode(micros as u128, INT_ENCODE_BASE).to_string()
 }
 
 fn string_to_timestamp(s: &str) -> Result<SystemTime, ()> {

compiler/rustc_middle/src/mir/mono.rs

@@ -325,7 +325,7 @@ impl<'tcx> CodegenUnit<'tcx> {
         human_readable_name.hash(&mut hasher);
         let hash: u128 = hasher.finish();
         let hash = hash & ((1u128 << 80) - 1);
-        base_n::encode(hash, base_n::CASE_INSENSITIVE)
+        base_n::encode(hash, base_n::CASE_INSENSITIVE).to_string()
     }
 
     pub fn estimate_size(&mut self, tcx: TyCtxt<'tcx>) {

src/tools/tidy/src/deps.rs

@@ -123,6 +123,7 @@ const PERMITTED_DEPENDENCIES: &[&str] = &[
     "humantime",
     "if_chain",
     "indexmap",
+    "inlinable_string",
     "instant",
     "itertools",
     "itoa",