[HACK] rustc_codegen_utils: try to reduce overhead of symbol mangling checks.

Author: eddyb

src/librustc_codegen_utils/symbol_names.rs

@@ -293,10 +293,13 @@ fn compute_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance
         return tcx.item_name(def_id).to_string();
     }
 
-    compute_mangled_symbol_name(tcx, instance)
+    dump::record(tcx, instance)
 }
 
-fn compute_mangled_symbol_name(tcx: TyCtxt<'_, 'tcx, 'tcx>, instance: Instance<'tcx>) -> String {
+fn compute_old_mangled_symbol_name(
+    tcx: TyCtxt<'_, 'tcx, 'tcx>,
+    instance: Instance<'tcx>,
+) -> (String, u64) {
     let def_id = instance.def_id();
 
     // We want to compute the "type" of this item. Unfortunately, some
@@ -340,11 +343,7 @@ fn compute_mangled_symbol_name(tcx: TyCtxt<'_, 'tcx, 'tcx>, instance: Instance<'
         sanitize(&mut buf.temp_buf, "{{vtable-shim}}");
     }
 
-    let mangled_symbol = buf.finish(hash);
-
-    return dump::record(tcx, instance, &mangled_symbol, hash);
-
-    // mangled_symbol
+    (buf.finish(hash), hash)
 }
 
 // Follow C++ namespace-mangling style, see

src/librustc_codegen_utils/symbol_names/dump.rs

@@ -22,38 +22,15 @@ thread_local!(static OUT_DIR: Option<PathBuf> = {
 });
 thread_local!(static OUTPUT: RefCell<Option<File>> = RefCell::new(None));
 
-pub fn record(
-    tcx: TyCtxt<'_, 'tcx, 'tcx>,
-    instance: Instance<'tcx>,
-    old_mangling: &str,
-    old_hash: u64,
-) -> String {
+pub fn record(tcx: TyCtxt<'_, 'tcx, 'tcx>, instance: Instance<'tcx>) -> String {
     let header = "old+generics,old,mw,mw+compression,new,new+compression";
 
-    // Always compute all forms of mangling.
     let def_id = instance.def_id();
     // FIXME(eddyb) this should ideally not be needed.
     let substs =
         tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), instance.substs);
 
-    let old_mangling_plus_generics = {
-        let mut symbol_path = old::SymbolPrinter {
-            tcx,
-            path: old::SymbolPath::new(),
-            keep_within_component: false,
-        }.print_def_path(def_id, substs).unwrap().path;
-
-        if instance.is_vtable_shim() {
-            symbol_path.finalize_pending_component();
-            old::sanitize(&mut symbol_path.temp_buf, "{{vtable-shim}}");
-        }
-
-        symbol_path.finish(old_hash)
-    };
-
-    let (mw_mangling, mw_mangling_plus_compression) = mw::mangle(tcx, instance)
-        .unwrap_or((String::new(), String::new()));
-    let (new_mangling, new_mangling_plus_compression) = new::mangle(tcx, instance);
+    let new_mangling_plus_compression = new::mangle(tcx, instance, true);
 
     OUTPUT.with(|out| {
         let mut out = out.borrow_mut();
@@ -93,6 +70,29 @@ pub fn record(
         }
 
         if let Some(out) = out.as_mut() {
+            let (old_mangling, old_hash) =
+                old::compute_old_mangled_symbol_name(tcx, instance);
+
+            let old_mangling_plus_generics = {
+                let mut symbol_path = old::SymbolPrinter {
+                    tcx,
+                    path: old::SymbolPath::new(),
+                    keep_within_component: false,
+                }.print_def_path(def_id, substs).unwrap().path;
+
+                if instance.is_vtable_shim() {
+                    symbol_path.finalize_pending_component();
+                    old::sanitize(&mut symbol_path.temp_buf, "{{vtable-shim}}");
+                }
+
+                symbol_path.finish(old_hash)
+            };
+
+            let (mw_mangling, mw_mangling_plus_compression) = mw::mangle(tcx, instance)
+                .unwrap_or((String::new(), String::new()));
+
+            let new_mangling = new::mangle(tcx, instance, false);
+
             writeln!(out, "{},{},{},{},{},{}",
                 old_mangling_plus_generics,
                 old_mangling,
@@ -124,17 +124,20 @@ pub fn record(
             cx.print_def_path(def_id, substs).unwrap().out
         }
     };
-    let expected_demangling_alt = make_expected_demangling(true);
+
+    // HACK(eddyb) some parts are commented out to reduce check overhead:
+
+    // let expected_demangling_alt = make_expected_demangling(true);
     let expected_demangling = make_expected_demangling(false);
 
-    for mangling in &[&new_mangling, &new_mangling_plus_compression] {
+    for mangling in &[/*&new_mangling,*/ &new_mangling_plus_compression] {
         match rustc_demangle::try_demangle(mangling) {
             Ok(demangling) => {
-                let demangling_alt = format!("{:#}", demangling);
+                /*let demangling_alt = format!("{:#}", demangling);
                 if demangling_alt.contains('?') {
                     bug!("demangle(alt) printing failed for {:?}\n{:?}", mangling, demangling_alt);
                 }
-                assert_eq!(demangling_alt, expected_demangling_alt);
+                assert_eq!(demangling_alt, expected_demangling_alt);*/
 
                 let demangling = format!("{}", demangling);
                 if demangling.contains('?') {

src/librustc_codegen_utils/symbol_names/new.rs

@@ -16,7 +16,8 @@ use std::ops::Range;
 pub(super) fn mangle(
     tcx: TyCtxt<'_, 'tcx, 'tcx>,
     instance: Instance<'tcx>,
-) -> (String, String) {
+    compress: bool,
+) -> String {
     let def_id = instance.def_id();
     // FIXME(eddyb) this should ideally not be needed.
     let substs =
@@ -41,27 +42,22 @@ pub(super) fn mangle(
 
     let prefix = "_R";
 
-    let uncompressed = print_symbol(SymbolMangler {
+    print_symbol(SymbolMangler {
         tcx,
-        compress: None,
-        binders: vec![],
-        out: String::from(prefix),
-    });
-
-    let compressed = print_symbol(SymbolMangler {
-        tcx,
-        compress: Some(Box::new(CompressionCaches {
-            start_offset: prefix.len(),
-
-            paths: FxHashMap::default(),
-            types: FxHashMap::default(),
-            consts: FxHashMap::default(),
-        })),
+        compress: if compress {
+            Some(Box::new(CompressionCaches {
+                start_offset: prefix.len(),
+
+                paths: FxHashMap::default(),
+                types: FxHashMap::default(),
+                consts: FxHashMap::default(),
+            }))
+        } else {
+            None
+        },
         binders: vec![],
         out: String::from(prefix),
-    });
-
-    (uncompressed, compressed)
+    })
 }
 
 struct CompressionCaches<'tcx> {