consider the align attribute when allocating a static

i.e. no longer have each backend do that, which is error-prone

Author: folkertdev

compiler/rustc_codegen_gcc/src/consts.rs

@@ -82,11 +82,8 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
             global.to_rvalue().set_type(val_llty);
         }
 
-        let align = match attrs.alignment {
-            Some(alignment) => Ord::max(alignment, alloc.align),
-            None => alloc.align,
-        };
-        set_global_alignment(self, global, align);
+        // NOTE: alignment from attributes has already been applied to the allocation.
+        set_global_alignment(self, global, alloc.align);
 
         global.global_set_initializer_rvalue(value);
 

compiler/rustc_codegen_llvm/src/consts.rs

@@ -453,12 +453,8 @@ impl<'ll> CodegenCx<'ll, '_> {
             new_g
         };
 
-        let align = match attrs.alignment {
-            Some(alignment) => Ord::max(alignment, alloc.align),
-            None => alloc.align,
-        };
-
-        set_global_alignment(self, g, align);
+        // NOTE: alignment from attributes has already been applied to the allocation.
+        set_global_alignment(self, g, alloc.align);
         llvm::set_initializer(g, v);
 
         self.assume_dso_local(g, true);

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -953,12 +953,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
         // # Global allocations
         if let Some(global_alloc) = self.tcx.try_get_global_alloc(id) {
-            let (size, mut align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
-            if let GlobalAlloc::Static(def_id) = global_alloc {
-                if let Some(static_align) = self.tcx.codegen_fn_attrs(def_id).alignment {
-                    align = Ord::max(align, static_align);
-                }
-            }
+            // NOTE: static alignment from attributes has already been applied to the allocation.
+            let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
                 GlobalAlloc::Static { .. } | GlobalAlloc::Memory { .. } => AllocKind::LiveData,

compiler/rustc_const_eval/src/interpret/util.rs

@@ -38,7 +38,13 @@ pub(crate) fn create_static_alloc<'tcx>(
     static_def_id: LocalDefId,
     layout: TyAndLayout<'tcx>,
 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
-    let alloc = Allocation::try_new(layout.size, layout.align.abi, AllocInit::Uninit, ())?;
+    // Take over-alignment from attributes into account.
+    let align = match ecx.tcx.codegen_fn_attrs(static_def_id).alignment {
+        Some(align_from_attribute) => Ord::max(align_from_attribute, layout.align.abi),
+        None => layout.align.abi,
+    };
+
+    let alloc = Allocation::try_new(layout.size, align, AllocInit::Uninit, ())?;
     let alloc_id = ecx.tcx.reserve_and_set_static_alloc(static_def_id.into());
     assert_eq!(ecx.machine.static_root_ids, None);
     ecx.machine.static_root_ids = Some((alloc_id, static_def_id));

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -386,7 +386,16 @@ impl<'tcx> GlobalAlloc<'tcx> {
                         .expect("statics should not have generic parameters");
                     let layout = tcx.layout_of(typing_env.as_query_input(ty)).unwrap();
                     assert!(layout.is_sized());
-                    (layout.size, layout.align.abi)
+
+                    // Take over-alignment from attributes into account.
+                    let align = match tcx.codegen_fn_attrs(def_id).alignment {
+                        Some(align_from_attribute) => {
+                            Ord::max(align_from_attribute, layout.align.abi)
+                        }
+                        None => layout.align.abi,
+                    };
+
+                    (layout.size, align)
                 }
             }
             GlobalAlloc::Memory(alloc) => {