revert changes and just delete the fixme

Avoiding the naming didn't have any meaningful perf impact.

Author: erikdesjardins

compiler/rustc_codegen_gcc/src/builder.rs

@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::convert::TryFrom;
-use std::fmt::Display;
 use std::ops::Deref;
 
 use gccjit::{
@@ -527,14 +526,14 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         self.block
     }
 
-    fn append_block(cx: &'a CodegenCx<'gcc, 'tcx>, func: RValue<'gcc>, name: impl Display) -> Block<'gcc> {
+    fn append_block(cx: &'a CodegenCx<'gcc, 'tcx>, func: RValue<'gcc>, name: &str) -> Block<'gcc> {
         let func = cx.rvalue_as_function(func);
-        func.new_block(name.to_string())
+        func.new_block(name)
     }
 
-    fn append_sibling_block(&mut self, name: impl Display) -> Block<'gcc> {
+    fn append_sibling_block(&mut self, name: &str) -> Block<'gcc> {
         let func = self.current_func();
-        func.new_block(name.to_string())
+        func.new_block(name)
     }
 
     fn switch_to_block(&mut self, block: Self::BasicBlock) {

compiler/rustc_codegen_llvm/src/builder.rs

@@ -26,7 +26,6 @@ use rustc_target::abi::{self, call::FnAbi, Align, Size, WrappingRange};
 use rustc_target::spec::{HasTargetSpec, SanitizerSet, Target};
 use smallvec::SmallVec;
 use std::borrow::Cow;
-use std::fmt::Display;
 use std::iter;
 use std::ops::Deref;
 use std::ptr;
@@ -154,24 +153,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn set_span(&mut self, _span: Span) {}
 
-    fn append_block(
-        cx: &'a CodegenCx<'ll, 'tcx>,
-        llfn: &'ll Value,
-        name: impl Display,
-    ) -> &'ll BasicBlock {
+    fn append_block(cx: &'a CodegenCx<'ll, 'tcx>, llfn: &'ll Value, name: &str) -> &'ll BasicBlock {
         unsafe {
-            let c_str_name;
-            let name_ptr = if cx.tcx.sess.fewer_names() {
-                const { c"".as_ptr().cast() }
-            } else {
-                c_str_name = SmallCStr::new(&name.to_string());
-                c_str_name.as_ptr()
-            };
-            llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, name_ptr)
+            let name = SmallCStr::new(name);
+            llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, name.as_ptr())
         }
     }
 
-    fn append_sibling_block(&mut self, name: impl Display) -> &'ll BasicBlock {
+    fn append_sibling_block(&mut self, name: &str) -> &'ll BasicBlock {
         Self::append_block(self.cx, self.llfn(), name)
     }
 

compiler/rustc_codegen_llvm/src/lib.rs

@@ -11,7 +11,6 @@
 #![feature(exact_size_is_empty)]
 #![feature(extern_types)]
 #![feature(hash_raw_entry)]
-#![feature(inline_const)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(impl_trait_in_assoc_type)]

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -83,11 +83,8 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
             // Cross-funclet jump - need a trampoline
             debug_assert!(base::wants_new_eh_instructions(fx.cx.tcx().sess));
             debug!("llbb_with_cleanup: creating cleanup trampoline for {:?}", target);
-            let trampoline_llbb = Bx::append_block(
-                fx.cx,
-                fx.llfn,
-                format_args!("{:?}_cleanup_trampoline_{:?}", self.bb, target),
-            );
+            let name = &format!("{:?}_cleanup_trampoline_{:?}", self.bb, target);
+            let trampoline_llbb = Bx::append_block(fx.cx, fx.llfn, name);
             let mut trampoline_bx = Bx::build(fx.cx, trampoline_llbb);
             trampoline_bx.cleanup_ret(self.funclet(fx).unwrap(), Some(lltarget));
             trampoline_llbb
@@ -1568,7 +1565,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     fn landing_pad_for_uncached(&mut self, bb: mir::BasicBlock) -> Bx::BasicBlock {
         let llbb = self.llbb(bb);
         if base::wants_new_eh_instructions(self.cx.sess()) {
-            let cleanup_bb = Bx::append_block(self.cx, self.llfn, format_args!("funclet_{bb:?}"));
+            let cleanup_bb = Bx::append_block(self.cx, self.llfn, &format!("funclet_{bb:?}"));
             let mut cleanup_bx = Bx::build(self.cx, cleanup_bb);
             let funclet = cleanup_bx.cleanup_pad(None, &[]);
             cleanup_bx.br(llbb);
@@ -1691,7 +1688,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn try_llbb(&mut self, bb: mir::BasicBlock) -> Option<Bx::BasicBlock> {
         match self.cached_llbbs[bb] {
             CachedLlbb::None => {
-                let llbb = Bx::append_block(self.cx, self.llfn, format_args!("{bb:?}"));
+                let llbb = Bx::append_block(self.cx, self.llfn, &format!("{bb:?}"));
                 self.cached_llbbs[bb] = CachedLlbb::Some(llbb);
                 Some(llbb)
             }

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -22,8 +22,6 @@ use rustc_target::abi::call::FnAbi;
 use rustc_target::abi::{Abi, Align, Scalar, Size, WrappingRange};
 use rustc_target::spec::HasTargetSpec;
 
-use std::fmt::Display;
-
 #[derive(Copy, Clone)]
 pub enum OverflowOp {
     Add,
@@ -51,13 +49,9 @@ pub trait BuilderMethods<'a, 'tcx>:
     fn set_span(&mut self, span: Span);
 
     // FIXME(eddyb) replace uses of this with `append_sibling_block`.
-    fn append_block(
-        cx: &'a Self::CodegenCx,
-        llfn: Self::Function,
-        name: impl Display,
-    ) -> Self::BasicBlock;
+    fn append_block(cx: &'a Self::CodegenCx, llfn: Self::Function, name: &str) -> Self::BasicBlock;
 
-    fn append_sibling_block(&mut self, name: impl Display) -> Self::BasicBlock;
+    fn append_sibling_block(&mut self, name: &str) -> Self::BasicBlock;
 
     fn switch_to_block(&mut self, llbb: Self::BasicBlock);