Merge addr_of_const and addr_of_mut

Author: oli-obk

compiler/rustc_codegen_gcc/src/common.rs

@@ -1,9 +1,7 @@
 use gccjit::{LValue, RValue, ToRValue, Type};
 use rustc_abi as abi;
 use rustc_abi::HasDataLayout;
-use rustc_codegen_ssa::traits::{
-    BaseTypeCodegenMethods, ConstCodegenMethods, StaticCodegenMethods as _,
-};
+use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, ConstCodegenMethods};
 use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::ty::layout::LayoutOf;
 
@@ -246,13 +244,48 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         self.context.new_cast(None, val, ty)
     }
 
-    fn static_addr_of_const(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value {
-        self.static_addr_of(alloc, kind)
-    }
-
-    fn static_addr_of_mut(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value {
+    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> RValue<'gcc> {
         let cv = const_alloc_to_gcc(self, alloc);
-        self.static_addr_of_mut(cv, alloc.inner().align, kind)
+        let align = alloc.inner().align;
+
+        if alloc.inner().mutability.is_not()
+            && let Some(variable) = self.const_globals.borrow().get(&cv)
+        {
+            if let Some(global_variable) = self.global_lvalues.borrow().get(variable) {
+                let alignment = align.bits() as i32;
+                if alignment > global_variable.get_alignment() {
+                    global_variable.set_alignment(alignment);
+                }
+            }
+            return *variable;
+        }
+        let global_value = match kind {
+            Some(kind) if !self.tcx.sess.fewer_names() => {
+                let name = self.generate_local_symbol_name(kind);
+                // FIXME(antoyo): check if it's okay that no link_section is set.
+
+                let typ = self.val_ty(cv).get_aligned(align.bytes());
+                self.declare_private_global(&name[..], typ)
+            }
+            _ => {
+                let typ = self.val_ty(cv).get_aligned(align.bytes());
+                self.declare_unnamed_global(typ)
+            }
+        };
+        global_value.global_set_initializer_rvalue(cv);
+        // FIXME(antoyo): set unnamed address.
+        let rvalue = global_value.get_address(None);
+        self.global_lvalues.borrow_mut().insert(rvalue, global_value);
+        if alloc.inner().mutability.is_not() {
+            #[cfg(feature = "master")]
+            self.global_lvalues
+                .borrow()
+                .get(&rvalue)
+                .expect("`static_addr_of_mut` did not add the global to `self.global_lvalues`")
+                .global_set_readonly();
+            self.const_globals.borrow_mut().insert(cv, rvalue);
+        }
+        rvalue
     }
 }
 

compiler/rustc_codegen_gcc/src/consts.rs

@@ -56,30 +56,6 @@ fn set_global_alignment<'gcc, 'tcx>(
 }
 
 impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
-    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> RValue<'gcc> {
-        let cv = const_alloc_to_gcc(self, alloc);
-        let align = alloc.inner().align;
-
-        if let Some(variable) = self.const_globals.borrow().get(&cv) {
-            if let Some(global_variable) = self.global_lvalues.borrow().get(variable) {
-                let alignment = align.bits() as i32;
-                if alignment > global_variable.get_alignment() {
-                    global_variable.set_alignment(alignment);
-                }
-            }
-            return *variable;
-        }
-        let global_value = self.static_addr_of_mut(cv, align, kind);
-        #[cfg(feature = "master")]
-        self.global_lvalues
-            .borrow()
-            .get(&global_value)
-            .expect("`static_addr_of_mut` did not add the global to `self.global_lvalues`")
-            .global_set_readonly();
-        self.const_globals.borrow_mut().insert(cv, global_value);
-        global_value
-    }
-
     fn codegen_static(&mut self, def_id: DefId) {
         let attrs = self.tcx.codegen_fn_attrs(def_id);
 
@@ -196,32 +172,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         function.add_attribute(FnAttribute::Used);
     }
 
-    pub fn static_addr_of_mut(
-        &self,
-        cv: RValue<'gcc>,
-        align: Align,
-        kind: Option<&str>,
-    ) -> RValue<'gcc> {
-        let global = match kind {
-            Some(kind) if !self.tcx.sess.fewer_names() => {
-                let name = self.generate_local_symbol_name(kind);
-                // FIXME(antoyo): check if it's okay that no link_section is set.
-
-                let typ = self.val_ty(cv).get_aligned(align.bytes());
-                self.declare_private_global(&name[..], typ)
-            }
-            _ => {
-                let typ = self.val_ty(cv).get_aligned(align.bytes());
-                self.declare_unnamed_global(typ)
-            }
-        };
-        global.global_set_initializer_rvalue(cv);
-        // FIXME(antoyo): set unnamed address.
-        let rvalue = global.get_address(None);
-        self.global_lvalues.borrow_mut().insert(rvalue, global);
-        rvalue
-    }
-
     pub fn get_static(&self, def_id: DefId) -> LValue<'gcc> {
         let instance = Instance::mono(self.tcx, def_id);
         let DefKind::Static { nested, .. } = self.tcx.def_kind(def_id) else { bug!() };

compiler/rustc_codegen_llvm/src/common.rs

@@ -289,14 +289,9 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         unsafe { llvm::LLVMConstPtrToInt(val, ty) }
     }
 
-    fn static_addr_of_const(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value {
+    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value {
         let cv = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
-        self.static_addr_of_const(cv, alloc.inner().align, kind)
-    }
-
-    fn static_addr_of_mut(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value {
-        let cv = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
-        self.static_addr_of_mut(cv, alloc.inner().align, kind)
+        self.static_addr_of(cv, alloc.inner().align, kind, alloc.inner().mutability)
     }
 }
 

compiler/rustc_codegen_llvm/src/consts.rs

@@ -1,6 +1,7 @@
 use std::ops::Range;
 
 use rustc_abi::{Align, HasDataLayout, Primitive, Scalar, Size, WrappingRange};
+use rustc_ast::Mutability;
 use rustc_codegen_ssa::common;
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::LangItem;
@@ -225,12 +226,26 @@ impl<'ll> CodegenCx<'ll, '_> {
     ///
     /// The returned global variable is a pointer in the default address space for globals.
     /// Fails if a symbol with the given name already exists.
-    pub(crate) fn static_addr_of_mut(
+    pub(crate) fn static_addr_of(
         &self,
         cv: &'ll Value,
         align: Align,
         kind: Option<&str>,
+        mutability: Mutability,
     ) -> &'ll Value {
+        if let Mutability::Not = mutability
+            && let Some(&gv) = self.const_globals.borrow().get(&cv)
+        {
+            unsafe {
+                // Upgrade the alignment in cases where the same constant is used with different
+                // alignment requirements
+                let llalign = align.bytes() as u32;
+                if llalign > llvm::LLVMGetAlignment(gv) {
+                    llvm::LLVMSetAlignment(gv, llalign);
+                }
+            }
+            return gv;
+        }
         let gv = match kind {
             Some(kind) if !self.tcx.sess.fewer_names() => {
                 let name = self.generate_local_symbol_name(kind);
@@ -247,33 +262,11 @@ impl<'ll> CodegenCx<'ll, '_> {
         llvm::set_initializer(gv, cv);
         set_global_alignment(self, gv, align);
         llvm::set_unnamed_address(gv, llvm::UnnamedAddr::Global);
-        gv
-    }
+        if let Mutability::Not = mutability {
+            llvm::set_global_constant(gv, true);
 
-    /// Create a global constant.
-    ///
-    /// The returned global variable is a pointer in the default address space for globals.
-    pub(crate) fn static_addr_of_const(
-        &self,
-        cv: &'ll Value,
-        align: Align,
-        kind: Option<&str>,
-    ) -> &'ll Value {
-        if let Some(&gv) = self.const_globals.borrow().get(&cv) {
-            unsafe {
-                // Upgrade the alignment in cases where the same constant is used with different
-                // alignment requirements
-                let llalign = align.bytes() as u32;
-                if llalign > llvm::LLVMGetAlignment(gv) {
-                    llvm::LLVMSetAlignment(gv, llalign);
-                }
-            }
-            return gv;
+            self.const_globals.borrow_mut().insert(cv, gv);
         }
-        let gv = self.static_addr_of_mut(cv, align, kind);
-        llvm::set_global_constant(gv, true);
-
-        self.const_globals.borrow_mut().insert(cv, gv);
         gv
     }
 
@@ -760,20 +753,6 @@ impl<'ll> CodegenCx<'ll, '_> {
 }
 
 impl<'ll> StaticCodegenMethods for CodegenCx<'ll, '_> {
-    /// Get a pointer to a global variable.
-    ///
-    /// The pointer will always be in the default address space. If global variables default to a
-    /// different address space, an addrspacecast is inserted.
-    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> &'ll Value {
-        // FIXME: should we cache `const_alloc_to_llvm` to avoid repeating this for the
-        // same `ConstAllocation`?
-        let cv = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
-        let gv = self.static_addr_of_const(cv, alloc.inner().align, kind);
-        // static_addr_of_const returns the bare global variable, which might not be in the default
-        // address space. Cast to the default address space if necessary.
-        self.const_pointercast(gv, self.type_ptr())
-    }
-
     fn codegen_static(&mut self, def_id: DefId) {
         self.codegen_static_item(def_id)
     }

compiler/rustc_codegen_ssa/src/traits/consts.rs

@@ -1,5 +1,4 @@
 use rustc_abi::{self as abi, HasDataLayout, Primitive};
-use rustc_ast::Mutability;
 use rustc_data_structures::stable_hash::{StableHash as _, StableHasher};
 use rustc_hashes::Hash128;
 use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
@@ -54,13 +53,12 @@ pub trait ConstCodegenMethods<'tcx>:
     fn const_pointercast(&self, val: Self::Value, ty: Self::Type) -> Self::Value;
     fn const_int_to_ptr(&self, val: Self::Value, ty: Self::Type) -> Self::Value;
     fn const_ptr_to_int(&self, val: Self::Value, ty: Self::Type) -> Self::Value;
+
     /// Create a global constant.
     ///
     /// The returned global variable is a pointer in the default address space for globals.
-    fn static_addr_of_const(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value;
-
-    /// Same as `static_addr_of_const`, but does not mark the static as immutable
-    fn static_addr_of_mut(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value;
+    /// Immutable allocations are deduplicated.
+    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value;
 
     fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Self::Type) -> Self::Value {
         let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
@@ -91,10 +89,7 @@ pub trait ConstCodegenMethods<'tcx>:
                                 self.const_bitcast(val, ty)
                             };
                         } else {
-                            let value = match alloc.inner().mutability {
-                                Mutability::Mut => self.static_addr_of_mut(alloc, None),
-                                _ => self.static_addr_of_const(alloc, None),
-                            };
+                            let value = self.static_addr_of(alloc, None);
                             self.set_value_name(value, || {
                                 let hash = self.tcx().with_stable_hashing_context(|mut hcx| {
                                     let mut hasher = StableHasher::new();
@@ -118,7 +113,7 @@ pub trait ConstCodegenMethods<'tcx>:
                                 }),
                             )))
                             .unwrap_memory();
-                        self.static_addr_of_const(alloc, None)
+                        self.static_addr_of(alloc, None)
                     }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx().is_static(def_id));

compiler/rustc_codegen_ssa/src/traits/statics.rs

@@ -1,10 +1,8 @@
 use rustc_hir::def_id::DefId;
-use rustc_middle::mir::interpret::ConstAllocation;
 
 use super::BackendTypes;
 
 pub trait StaticCodegenMethods: BackendTypes {
-    fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Self::Value;
     /// Set a debuginfo name. The name closure is only invoked if a name actually needs to be
     /// registered, so you can do expensive name calculations in it.
     fn set_value_name(&self, val: Self::Value, gen_name: impl FnOnce() -> String);