mitigate MSVC unsoundness by not emitting alignment attributes on win32-msvc targets

Author: RalfJung

compiler/rustc_codegen_llvm/src/builder.rs

@@ -594,7 +594,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn load(&mut self, ty: &'ll Type, ptr: &'ll Value, align: Align) -> &'ll Value {
         unsafe {
             let load = llvm::LLVMBuildLoad2(self.llbuilder, ty, ptr, UNNAMED);
-            llvm::LLVMSetAlignment(load, align.bytes() as c_uint);
+            if !self.cx().tcx.sess.target.has_unreliable_alignment() {
+                llvm::LLVMSetAlignment(load, align.bytes() as c_uint);
+            }
             load
         }
     }
@@ -809,7 +811,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
             let align =
                 if flags.contains(MemFlags::UNALIGNED) { 1 } else { align.bytes() as c_uint };
-            llvm::LLVMSetAlignment(store, align);
+            if !self.cx().tcx.sess.target.has_unreliable_alignment() {
+                llvm::LLVMSetAlignment(store, align);
+            }
             if flags.contains(MemFlags::VOLATILE) {
                 llvm::LLVMSetVolatile(store, llvm::True);
             }

compiler/rustc_mir_transform/src/check_alignment.rs

@@ -11,8 +11,7 @@ pub(super) struct CheckAlignment;
 
 impl<'tcx> crate::MirPass<'tcx> for CheckAlignment {
     fn is_enabled(&self, sess: &Session) -> bool {
-        // FIXME(#112480) MSVC and rustc disagree on minimum stack alignment on x86 Windows
-        if sess.target.llvm_target == "i686-pc-windows-msvc" {
+        if sess.target.has_unreliable_alignment() {
             return false;
         }
         sess.ub_checks()

compiler/rustc_target/src/callconv/mod.rs

@@ -144,6 +144,7 @@ pub struct ArgAttributes {
     /// (corresponding to LLVM's dereferenceable_or_null attributes, i.e., it is okay for this to be
     /// set on a null pointer, but all non-null pointers must be dereferenceable).
     pub pointee_size: Size,
+    /// The minimum alignment of the pointee, if any.
     pub pointee_align: Option<Align>,
 }
 

compiler/rustc_target/src/spec/mod.rs

@@ -3602,6 +3602,24 @@ impl Target {
             _ => return None,
         })
     }
+
+    /// Returns whether this target is known to have unreliable alignment:
+    /// native C code for the target fails to align some data to the degree
+    /// required by the C standard. We can't *really* do anything about that
+    /// since unsafe Rust code may assume alignment any time, but we can at least
+    /// inhibit some optimizations, and we suppress the alignment checks that
+    /// would detect this unsoundness.
+    ///
+    /// Every `return true` here is still a soundness bug for that target.
+    pub fn has_unreliable_alignment(&self) -> bool {
+        // FIXME(#112480) MSVC on x86-32 is unsound and fails to properly align many types with
+        // more-than-4-byte-alignment on the stack.
+        if self.is_like_msvc && self.arch == "x86" {
+            return true;
+        }
+
+        false
+    }
 }
 
 /// Either a target tuple string or a path to a JSON file.

compiler/rustc_ty_utils/src/abi.rs

@@ -347,7 +347,9 @@ fn adjust_for_rust_scalar<'tcx>(
             None
         };
         if let Some(kind) = kind {
-            attrs.pointee_align = Some(pointee.align);
+            if !cx.tcx().sess.target.has_unreliable_alignment() {
+                attrs.pointee_align = Some(pointee.align);
+            }
 
             // `Box` are not necessarily dereferenceable for the entire duration of the function as
             // they can be deallocated at any time. Same for non-frozen shared references (see