Generate unique symbol names if const pointers refer to promoted static

Author: nbdd0121

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::{
@@ -97,6 +97,19 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             }
         };
 
+        if need_symbol_name {
+            let name = self.generate_global_symbol_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(&name, typ, GlobalKind::Internal);
+
+            global.global_set_initializer_rvalue(init);
+            return Ok((global.get_address(None), Some(SymbolName::new(self.tcx, &name))));
+        }
+
         let value = match alloc.inner().mutability {
             Mutability::Mut => {
                 self.static_addr_of_mut(const_alloc_to_gcc(self, alloc), alloc.inner().align, None)

compiler/rustc_codegen_gcc/src/context.rs

@@ -117,6 +117,9 @@ pub struct CodegenCx<'gcc, 'tcx> {
     /// A counter that is used for generating local symbol names
     local_gen_sym_counter: Cell<usize>,
 
+    /// A counter that is used for generating global symbol names
+    global_gen_sym_counter: Cell<usize>,
+
     eh_personality: Cell<Option<Function<'gcc>>>,
     #[cfg(feature = "master")]
     pub rust_try_fn: Cell<Option<(Type<'gcc>, Function<'gcc>)>>,
@@ -296,6 +299,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             tcx,
             struct_types: Default::default(),
             local_gen_sym_counter: Cell::new(0),
+            global_gen_sym_counter: Cell::new(0),
             eh_personality: Cell::new(None),
             #[cfg(feature = "master")]
             rust_try_fn: Cell::new(None),
@@ -595,6 +599,24 @@ impl<'b, 'tcx> CodegenCx<'b, 'tcx> {
         name.push_str(&(idx as u64 + ALPHANUMERIC_ONLY as u64).to_base(ALPHANUMERIC_ONLY));
         name
     }
+
+    /// Generates a new global symbol name with the given prefix. This symbol name must
+    /// only be used for definitions with `internal` or `private` linkage.
+    pub fn generate_global_symbol_name(&self) -> String {
+        let idx = self.global_gen_sym_counter.get();
+        self.global_gen_sym_counter.set(idx + 1);
+
+        let sym = self.codegen_unit.symbol_name();
+        let prefix = sym.as_str();
+        let mut name = String::with_capacity(prefix.len() + 6);
+        name.push_str(prefix);
+        name.push('.');
+        // Offset the index by the base so that always at least two characters
+        // are generated. This avoids cases where the suffix is interpreted as
+        // size by the assembler (for m68k: .b, .w, .l).
+        name.push_str(&(idx as u64 + ALPHANUMERIC_ONLY as u64).to_base(ALPHANUMERIC_ONLY));
+        name
+    }
 }
 
 fn to_gcc_tls_mode(tls_model: TlsModel) -> gccjit::TlsModel {

compiler/rustc_codegen_llvm/src/common.rs

@@ -181,10 +181,25 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             }
         };
 
-        assert!(!need_symbol_name);
-
         let init = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
         let alloc = alloc.inner();
+
+        if need_symbol_name {
+            // If a symbol name is needed, use `static_addr_of_mut` so we can give it unique symbol names.
+            let value = self.static_addr_of_mut(init, alloc.align, None);
+            if alloc.mutability.is_not() {
+                llvm::set_global_constant(value, true);
+            }
+
+            // Even though we're generating with internal linkage, this symbol name still needs to
+            // be globally unique. LTO can rename symbol names if there are duplicates, but the
+            // names inserted into global asm as text cannot be updated.
+            let name = self.generate_global_symbol_name();
+            llvm::set_value_name(value, name.as_bytes());
+            llvm::set_linkage(value, llvm::Linkage::InternalLinkage);
+            return Ok(value);
+        }
+
         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),

compiler/rustc_codegen_llvm/src/context.rs

@@ -143,6 +143,9 @@ pub(crate) struct FullCx<'ll, 'tcx> {
     /// A counter that is used for generating local symbol names
     local_gen_sym_counter: Cell<usize>,
 
+    /// A counter that is used for generating global symbol names
+    global_gen_sym_counter: Cell<usize>,
+
     /// `codegen_static` will sometimes create a second global variable with a
     /// different type and clear the symbol name of the original global.
     /// `global_asm!` needs to be able to find this new global so that it can
@@ -681,6 +684,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 rust_try_fn: Cell::new(None),
                 intrinsics: Default::default(),
                 local_gen_sym_counter: Cell::new(0),
+                global_gen_sym_counter: Cell::new(0),
                 renamed_statics: Default::default(),
                 objc_class_t: Cell::new(None),
                 objc_classrefs: Default::default(),
@@ -1063,6 +1067,20 @@ impl CodegenCx<'_, '_> {
         name.push_str(&(idx as u64).to_base(ALPHANUMERIC_ONLY));
         name
     }
+
+    /// Generates a new global symbol name with the given prefix.
+    pub(crate) fn generate_global_symbol_name(&self) -> String {
+        let idx = self.global_gen_sym_counter.get();
+        self.global_gen_sym_counter.set(idx + 1);
+
+        let sym = self.codegen_unit.symbol_name();
+        let prefix = sym.as_str();
+        let mut name = String::with_capacity(prefix.len() + 6);
+        name.push_str(prefix);
+        name.push('.');
+        name.push_str(&(idx as u64).to_base(ALPHANUMERIC_ONLY));
+        name
+    }
 }
 
 impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {