Set the pointer alignment to 1 whenever any niche is non-zero

Author: dianqk

compiler/rustc_middle/src/ty/layout.rs

@@ -999,7 +999,7 @@ where
             }
 
             _ => {
-                let mut data_variant = match this.variants {
+                let (mut data_variant, align) = match this.variants {
                     // Within the discriminant field, only the niche itself is
                     // always initialized, so we only check for a pointer at its
                     // offset.
@@ -1012,13 +1012,24 @@ where
                     // using more niches than just null (e.g., the first page of
                     // the address space, or unaligned pointers).
                     Variants::Multiple {
-                        tag_encoding: TagEncoding::Niche { untagged_variant, .. },
+                        tag_encoding:
+                            TagEncoding::Niche { untagged_variant, ref niche_variants, .. },
                         tag_field,
                         ..
                     } if this.fields.offset(tag_field) == offset => {
-                        Some(this.for_variant(cx, untagged_variant))
+                        // When a non-zero niche exists, we cannot safely keep
+                        // the alignment of the pointer. These niches typically
+                        // don't meet the alignment requirements of the pointer.
+                        let align = if niche_variants.start().as_u32() != 0
+                            || niche_variants.end().as_u32() != 0
+                        {
+                            Some(Align::ONE)
+                        } else {
+                            None
+                        };
+                        (Some(this.for_variant(cx, untagged_variant)), align)
                     }
-                    _ => Some(this),
+                    _ => (Some(this), None),
                 };
 
                 if let Some(variant) = data_variant {
@@ -1055,20 +1066,23 @@ where
                     }
                 }
 
-                // Fixup info for the first field of a `Box`. Recursive traversal will have found
-                // the raw pointer, so size and align are set to the boxed type, but `pointee.safe`
-                // will still be `None`.
                 if let Some(ref mut pointee) = result {
                     if offset.bytes() == 0
                         && let Some(boxed_ty) = this.ty.boxed_ty()
                     {
+                        // Fixup info for the first field of a `Box`. Recursive traversal will have found
+                        // the raw pointer, so size and align are set to the boxed type, but `pointee.safe`
+                        // will still be `None`.
                         debug_assert!(pointee.safe.is_none());
                         let optimize = tcx.sess.opts.optimize != OptLevel::No;
                         pointee.safe = Some(PointerKind::Box {
                             unpin: optimize && boxed_ty.is_unpin(tcx, cx.param_env()),
                             global: this.ty.is_box_global(tcx),
                         });
                     }
+                    if let Some(align) = align {
+                        pointee.align = align;
+                    }
                 }
 
                 result

tests/codegen/enum/enum-ptr-align-niche.rs

@@ -0,0 +1,30 @@
+//@ compile-flags: -Cno-prepopulate-passes
+//@ only-64bit (I don't care about alignment under different bits)
+//@ revisions: OPT0 OPT3
+//@ [OPT0] compile-flags: -Copt-level=0
+//@ [OPT3] compile-flags: -Copt-level=3
+
+#![crate_type = "rlib"]
+#![feature(rustc_attrs)]
+
+#[rustc_layout_scalar_valid_range_start(1)]
+#[rustc_layout_scalar_valid_range_end(0x7fff)]
+pub struct RestrictedAddress(&'static i64);
+
+enum Variant {
+    A,
+    B(RestrictedAddress),
+    C,
+}
+
+// When a non-zero niche exists, we cannot safely keep the alignment of the pointer.
+// CHECK-LABEL: @multiple_niches
+// CHECK-SAME: align 1
+#[no_mangle]
+#[inline(never)]
+pub fn multiple_niches(a: Variant) {}
+
+// CHECK-LABEL: @single_niche
+// CHECK-SAME: align 8
+#[no_mangle]
+pub fn single_niche(a: Option<&'static i64>) {}