Generate unique symbol names if const pointers refer to promoted static

Author: nbdd0121

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -109,7 +109,7 @@ fn codegen_global_asm_inner<'tcx>(
             InlineAsmTemplatePiece::String(ref s) => global_asm.push_str(s),
             InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span } => {
                 match operands[operand_idx] {
-                    GlobalAsmOperandRef::Const { value, ty } => {
+                    GlobalAsmOperandRef::Const { value, ty, instance: _ } => {
                         match value {
                             ConstScalar::Int(int) => {
                                 let string = rustc_codegen_ssa::common::asm_const_to_str(

compiler/rustc_codegen_gcc/src/asm.rs

@@ -404,12 +404,12 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     // processed in the previous pass
                 }
 
-                InlineAsmOperandRef::Const { value, ty: _ } => match value {
+                InlineAsmOperandRef::Const { value, ty: _, instance } => match value {
                     Scalar::Int(_) => (),
                     Scalar::Ptr(ptr, _) => {
                         let (prov, _) = ptr.prov_and_relative_offset();
                         let global_alloc = self.tcx.global_alloc(prov.alloc_id());
-                        let (val, sym) = self.cx.alloc_to_backend(global_alloc).unwrap();
+                        let (val, sym) = self.cx.alloc_to_backend(global_alloc, instance).unwrap();
                         const_syms.push(sym.unwrap());
                         inputs.push(AsmInOperand { constraint: "X".into(), rust_idx, val });
                     }
@@ -495,7 +495,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                             push_to_template(modifier, gcc_index);
                         }
 
-                        InlineAsmOperandRef::Const { value, ty } => {
+                        InlineAsmOperandRef::Const { value, ty, instance: _ } => {
                             match value {
                                 Scalar::Int(int) => {
                                     // Const operands get injected directly into the template
@@ -910,7 +910,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 }
                 InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
-                        GlobalAsmOperandRef::Const { value, ty } => {
+                        GlobalAsmOperandRef::Const { value, ty, instance } => {
                             match value {
                                 Scalar::Int(int) => {
                                     // Const operands get injected directly into the
@@ -937,8 +937,9 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                                             self.tcx.symbol_name(instance)
                                         }
                                         _ => {
-                                            let (_, syms) =
-                                                self.alloc_to_backend(global_alloc).unwrap();
+                                            let (_, syms) = self
+                                                .alloc_to_backend(global_alloc, instance)
+                                                .unwrap();
                                             // TODO(antoyo): set the global variable as used.
                                             // TODO(@Amanieu): Additional mangling is needed on
                                             // some targets to add a leading underscore (Mach-O).

compiler/rustc_codegen_gcc/src/common.rs

@@ -1,4 +1,4 @@
-use gccjit::{LValue, RValue, ToRValue, Type};
+use gccjit::{GlobalKind, LValue, RValue, ToRValue, Type};
 use rustc_abi::Primitive::Pointer;
 use rustc_abi::{self as abi, HasDataLayout};
 use rustc_codegen_ssa::traits::{
@@ -224,6 +224,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     fn alloc_to_backend(
         &self,
         global_alloc: GlobalAlloc<'tcx>,
+        name_hint: Option<Instance<'tcx>>,
     ) -> Result<(RValue<'gcc>, Option<Instance<'tcx>>), u64> {
         let alloc = match global_alloc {
             GlobalAlloc::Function { instance, .. } => {
@@ -265,6 +266,18 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
             }
         };
 
+        if let Some(name) = name_hint {
+            let sym = self.tcx.symbol_name(name);
+
+            let init = crate::consts::const_alloc_to_gcc_uncached(self, alloc);
+            let alloc = alloc.inner();
+            let typ = self.val_ty(init).get_aligned(alloc.align.bytes());
+
+            let global = self.declare_global_with_linkage(sym.name, typ, GlobalKind::Exported);
+            global.global_set_initializer_rvalue(init);
+            return Ok((global.get_address(None), Some(name)));
+        }
+
         let init = self.const_data_from_alloc(alloc);
         let alloc = alloc.inner();
         let value = match alloc.mutability {
@@ -299,7 +312,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
             Scalar::Ptr(ptr, _size) => {
                 let (prov, offset) = ptr.prov_and_relative_offset();
                 let alloc_id = prov.alloc_id();
-                let base_addr = match self.alloc_to_backend(self.tcx.global_alloc(alloc_id)) {
+                let base_addr = match self.alloc_to_backend(self.tcx.global_alloc(alloc_id), None) {
                     Ok((base_addr, _)) => base_addr,
                     Err(base_addr) => {
                         let val = base_addr.wrapping_add(offset.bytes());

compiler/rustc_codegen_llvm/src/asm.rs

@@ -159,12 +159,12 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         constraints.push(format!("{}", op_idx[&idx]));
                     }
                 }
-                InlineAsmOperandRef::Const { value, ty: _ } => match value {
+                InlineAsmOperandRef::Const { value, ty: _, instance: _ } => match value {
                     ConstScalar::Int(_) => (),
                     ConstScalar::Ptr(ptr, _) => {
                         let (prov, _) = ptr.prov_and_relative_offset();
                         let global_alloc = self.tcx.global_alloc(prov.alloc_id());
-                        let (value, _) = self.cx.alloc_to_backend(global_alloc).unwrap();
+                        let (value, _) = self.cx.alloc_to_backend(global_alloc, None).unwrap();
                         inputs.push(value);
                         op_idx.insert(idx, constraints.len());
                         constraints.push("s".to_string());
@@ -212,7 +212,7 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                                 template_str.push_str(&format!("${{{}}}", op_idx[&operand_idx]));
                             }
                         }
-                        InlineAsmOperandRef::Const { value, ty } => {
+                        InlineAsmOperandRef::Const { value, ty, instance: _ } => {
                             match value {
                                 ConstScalar::Int(int) => {
                                     // Const operands get injected directly into the template
@@ -431,7 +431,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
                 InlineAsmTemplatePiece::String(ref s) => template_str.push_str(s),
                 InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
-                        GlobalAsmOperandRef::Const { value, ty } => {
+                        GlobalAsmOperandRef::Const { value, ty, instance } => {
                             match value {
                                 ConstScalar::Int(int) => {
                                     // Const operands get injected directly into the
@@ -448,7 +448,8 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
                                 ConstScalar::Ptr(ptr, _) => {
                                     let (prov, offset) = ptr.prov_and_relative_offset();
                                     let global_alloc = self.tcx.global_alloc(prov.alloc_id());
-                                    let (llval, sym) = self.alloc_to_backend(global_alloc).unwrap();
+                                    let (llval, sym) =
+                                        self.alloc_to_backend(global_alloc, instance).unwrap();
                                     assert!(sym.is_some());
 
                                     self.add_compiler_used_global(llval);

compiler/rustc_codegen_llvm/src/common.rs

@@ -263,6 +263,7 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn alloc_to_backend(
         &self,
         global_alloc: GlobalAlloc<'tcx>,
+        name_hint: Option<Instance<'tcx>>,
     ) -> Result<(Self::Value, Option<Instance<'tcx>>), u64> {
         let alloc = match global_alloc {
             GlobalAlloc::Function { instance, .. } => {
@@ -312,6 +313,22 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
         let init = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
         let alloc = alloc.inner();
+
+        if let Some(name) = name_hint {
+            let sym = self.tcx.symbol_name(name);
+
+            // If a hint is provided, always use `static_addr_of_mut`, as `static_addr_of_impl` may
+            // deduplicate and provide one that doesn't have a desired name.
+            let value = self.static_addr_of_mut(init, alloc.align, None);
+            if alloc.mutability.is_not() {
+                llvm::set_global_constant(value, true);
+            }
+
+            llvm::set_value_name(value, sym.name.as_bytes());
+            llvm::set_linkage(value, llvm::Linkage::InternalLinkage);
+            return Ok((value, Some(name)));
+        }
+
         let value = match alloc.mutability {
             Mutability::Mut => self.static_addr_of_mut(init, alloc.align, None),
             _ => self.static_addr_of_impl(init, alloc.align, None),
@@ -344,7 +361,7 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 let (prov, offset) = ptr.prov_and_relative_offset();
                 let global_alloc = self.tcx.global_alloc(prov.alloc_id());
                 let base_addr_space = global_alloc.address_space(self);
-                let base_addr = match self.alloc_to_backend(global_alloc) {
+                let base_addr = match self.alloc_to_backend(global_alloc, None) {
                     Ok((base_addr, _)) => base_addr,
                     Err(base_addr) => {
                         let val = base_addr.wrapping_add(offset.bytes());

compiler/rustc_codegen_ssa/src/base.rs

@@ -407,7 +407,8 @@ where
             .iter()
             .map(|(op, op_sp)| match *op {
                 rustc_hir::InlineAsmOperand::Const { ref anon_const } => {
-                    match cx.tcx().const_eval_poly(anon_const.def_id.to_def_id()) {
+                    let def_id = anon_const.def_id.to_def_id();
+                    match cx.tcx().const_eval_poly(def_id) {
                         Ok(const_value) => {
                             let ty =
                                 cx.tcx().typeck_body(anon_const.body).node_type(anon_const.hir_id);
@@ -421,6 +422,10 @@ where
                             GlobalAsmOperandRef::Const {
                                 value: common::asm_const_ptr_clean(cx.tcx(), scalar),
                                 ty,
+                                instance: Some(Instance::new_raw(
+                                    def_id,
+                                    ty::GenericArgs::identity_for_item(cx.tcx(), def_id),
+                                )),
                             }
                         }
                         Err(ErrorHandled::Reported { .. }) => {
@@ -430,6 +435,7 @@ where
                             GlobalAsmOperandRef::Const {
                                 value: Scalar::from_u32(0),
                                 ty: Ty::new_uint(cx.tcx(), UintTy::U32),
+                                instance: None,
                             }
                         }
                         Err(ErrorHandled::TooGeneric(_)) => {
@@ -456,6 +462,7 @@ where
                             cx,
                         ),
                         ty: Ty::new_fn_ptr(cx.tcx(), ty.fn_sig(cx.tcx())),
+                        instance: None,
                     }
                 }
                 rustc_hir::InlineAsmOperand::SymStatic { path: _, def_id } => {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -7,7 +7,9 @@ use rustc_data_structures::packed::Pu128;
 use rustc_hir::lang_items::LangItem;
 use rustc_lint_defs::builtin::TAIL_CALL_TRACK_CALLER;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, Scalar};
-use rustc_middle::mir::{self, AssertKind, InlineAsmMacro, SwitchTargets, UnwindTerminateReason};
+use rustc_middle::mir::{
+    self, AssertKind, Const, InlineAsmMacro, SwitchTargets, UnwindTerminateReason,
+};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
 use rustc_middle::ty::{self, Instance, Ty};
@@ -1268,6 +1270,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     InlineAsmOperandRef::InOut { reg, late, in_value, out_place }
                 }
                 mir::InlineAsmOperand::Const { ref value } => {
+                    let Const::Unevaluated(c, _) = &value.const_ else {
+                        bug!("need unevaluated const to derive symbol name")
+                    };
+                    let const_instance = Instance::new_raw(c.def, c.args);
+
                     let const_value = self.eval_mir_constant(value);
                     let mir::ConstValue::Scalar(scalar) = const_value else {
                         span_bug!(
@@ -1279,6 +1286,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     InlineAsmOperandRef::Const {
                         value: common::asm_const_ptr_clean(bx.tcx(), scalar),
                         ty: value.ty(),
+                        instance: Some(const_instance),
                     }
                 }
                 mir::InlineAsmOperand::SymFn { ref value } => {
@@ -1298,6 +1306,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 bx,
                             ),
                             ty: Ty::new_fn_ptr(bx.tcx(), const_.ty().fn_sig(bx.tcx())),
+                            instance: None,
                         }
                     } else {
                         span_bug!(span, "invalid type for asm sym (fn)");

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -2,7 +2,7 @@ use rustc_abi::{BackendRepr, Float, Integer, Primitive, RegKind};
 use rustc_hir::attrs::{InstructionSetAttr, Linkage};
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, Scalar};
 use rustc_middle::mir::mono::{MonoItemData, Visibility};
-use rustc_middle::mir::{self, InlineAsmOperand, START_BLOCK};
+use rustc_middle::mir::{self, Const, InlineAsmOperand, START_BLOCK};
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{Instance, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug, ty};
@@ -63,6 +63,11 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
 ) -> GlobalAsmOperandRef<'tcx> {
     match op {
         InlineAsmOperand::Const { value } => {
+            let Const::Unevaluated(c, _) = &value.const_ else {
+                bug!("need unevaluated const to derive symbol name")
+            };
+            let const_instance = Instance::new_raw(c.def, c.args);
+
             let const_value = instance
                 .instantiate_mir_and_normalize_erasing_regions(
                     cx.tcx(),
@@ -88,6 +93,7 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
             GlobalAsmOperandRef::Const {
                 value: common::asm_const_ptr_clean(cx.tcx(), scalar),
                 ty: mono_type,
+                instance: Some(const_instance),
             }
         }
         InlineAsmOperand::SymFn { value } => {
@@ -110,6 +116,7 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
                     cx,
                 ),
                 ty: Ty::new_fn_ptr(cx.tcx(), mono_type.fn_sig(cx.tcx())),
+                instance: None,
             }
         }
         InlineAsmOperand::SymStatic { def_id } => {

compiler/rustc_codegen_ssa/src/traits/asm.rs

@@ -30,6 +30,10 @@ pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
         value: Scalar,
         /// Type of the constant. This is needed to extract width and signedness.
         ty: Ty<'tcx>,
+        /// Instance to the const that produces this operand.
+        ///
+        /// This is used to be able to generate unique name for promoted statics.
+        instance: Option<Instance<'tcx>>,
     },
     SymStatic {
         def_id: DefId,
@@ -45,6 +49,10 @@ pub enum GlobalAsmOperandRef<'tcx> {
         value: Scalar,
         /// Type of the constant. This is needed to extract width and signedness.
         ty: Ty<'tcx>,
+        /// Instance to the const that produces this operand.
+        ///
+        /// This is used to be able to generate unique name for promoted statics.
+        instance: Option<Instance<'tcx>>,
     },
     SymStatic {
         def_id: DefId,

compiler/rustc_codegen_ssa/src/traits/consts.rs

@@ -45,9 +45,13 @@ pub trait ConstCodegenMethods<'tcx>: BackendTypes {
     ///
     /// If the `GlobalAlloc` should not be mapped to a global, but absolute address should be used,
     /// an integer is returned as `Err` instead.
+    ///
+    /// If the caller needs to guarantee a symbol name, it can provide a name hint. The name will be
+    /// used to generate a new symbol if there isn't one already (i.e. the case of fn/static).
     fn alloc_to_backend(
         &self,
         global_alloc: GlobalAlloc<'tcx>,
+        name_hint: Option<Instance<'tcx>>,
     ) -> Result<(Self::Value, Option<Instance<'tcx>>), u64>;
     fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, llty: Self::Type) -> Self::Value;