Make the alignment intrinsics return ptr::Alignment

Author: scottmcm

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -686,6 +686,12 @@ pub union MaybeUninit<T> {
     pub value: ManuallyDrop<T>,
 }
 
+pub mod mem {
+    #[lang = "Alignment"]
+    #[repr(transparent)]
+    pub struct Alignment(pub usize);
+}
+
 pub mod intrinsics {
     #[rustc_intrinsic]
     pub fn abort() -> !;
@@ -694,9 +700,9 @@ pub mod intrinsics {
     #[rustc_intrinsic]
     pub unsafe fn size_of_val<T: ?crate::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
-    pub const fn align_of<T>() -> usize;
+    pub const fn align_of<T>() -> crate::ptr::Alignment;
     #[rustc_intrinsic]
-    pub unsafe fn align_of_val<T: ?crate::Sized>(val: *const T) -> usize;
+    pub unsafe fn align_of_val<T: ?crate::Sized>(val: *const T) -> crate::ptr::Alignment;
     #[rustc_intrinsic]
     pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
     #[rustc_intrinsic]
@@ -764,15 +770,15 @@ pub const fn size_of<T>() -> usize {
 }
 
 pub const fn align_of<T>() -> usize {
-    <T as SizedTypeProperties>::ALIGN
+    <T as SizedTypeProperties>::ALIGN.0
 }
 
 trait SizedTypeProperties: Sized {
     #[lang = "mem_size_const"]
     const SIZE: usize = intrinsics::size_of::<Self>();
 
     #[lang = "mem_align_const"]
-    const ALIGN: usize = intrinsics::align_of::<Self>();
+    const ALIGN: crate::ptr::Alignment = intrinsics::align_of::<Self>();
 }
 impl<T> SizedTypeProperties for T {}
 

compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs

@@ -220,7 +220,7 @@ fn main() {
         assert_eq!(intrinsics::size_of_val(&0u32) as u8, 4);
 
         assert_eq!(align_of::<u16>() as u8, 2);
-        assert_eq!(intrinsics::align_of_val(&a) as u8, align_of::<&str>() as u8);
+        assert_eq!(intrinsics::align_of_val(&a).0 as u8, align_of::<&str>() as u8);
 
         let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
         assert!(!u8_needs_drop);

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -592,7 +592,8 @@ fn codegen_regular_intrinsic_call<'tcx>(
                 None
             };
             let (_size, align) = crate::unsize::size_and_align_of(fx, layout, meta);
-            ret.write_cvalue(fx, CValue::by_val(align, usize_layout));
+            let alignment_layout = fx.layout_of(fx.tcx.ty_alignment(source_info.span));
+            ret.write_cvalue(fx, CValue::by_val(align, alignment_layout));
         }
 
         sym::vtable_size => {

compiler/rustc_codegen_gcc/example/mini_core.rs

@@ -694,6 +694,12 @@ pub union MaybeUninit<T> {
     pub value: ManuallyDrop<T>,
 }
 
+pub mod mem {
+    #[lang = "Alignment"]
+    #[repr(transparent)]
+    pub struct Alignment(pub usize);
+}
+
 pub mod intrinsics {
     #[rustc_intrinsic]
     pub const fn black_box<T>(_dummy: T) -> T;
@@ -704,9 +710,9 @@ pub mod intrinsics {
     #[rustc_intrinsic]
     pub unsafe fn size_of_val<T: ?::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
-    pub const fn align_of<T>() -> usize;
+    pub const fn align_of<T>() -> crate::mem::Alignment;
     #[rustc_intrinsic]
-    pub unsafe fn align_of_val<T: ?::Sized>(val: *const T) -> usize;
+    pub unsafe fn align_of_val<T: ?::Sized>(val: *const T) -> crate::mem::Alignment;
     #[rustc_intrinsic]
     pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
     #[rustc_intrinsic]
@@ -747,15 +753,15 @@ pub const fn size_of<T>() -> usize {
 }
 
 pub const fn align_of<T>() -> usize {
-    <T as SizedTypeProperties>::ALIGN
+    <T as SizedTypeProperties>::ALIGN.0
 }
 
 trait SizedTypeProperties: Sized {
     #[lang = "mem_size_const"]
     const SIZE: usize = intrinsics::size_of::<Self>();
 
     #[lang = "mem_align_const"]
-    const ALIGN: usize = intrinsics::align_of::<Self>();
+    const ALIGN: crate::ptr::Alignment = intrinsics::align_of::<Self>();
 }
 
 impl<T> SizedTypeProperties for T {}

compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs

@@ -196,7 +196,7 @@ fn main() {
         assert_eq!(intrinsics::size_of_val(&0u32) as u8, 4);
 
         assert_eq!(align_of::<u16>() as u8, 2);
-        assert_eq!(intrinsics::align_of_val(&a) as u8, align_of::<&str>() as u8);
+        assert_eq!(intrinsics::align_of_val(&a).0 as u8, align_of::<&str>() as u8);
 
         let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
         assert!(!u8_needs_drop);

compiler/rustc_hir/src/lang_items.rs

@@ -156,6 +156,7 @@ language_item_table! {
     MetaSized,               sym::meta_sized,          meta_sized_trait,           Target::Trait,          GenericRequirement::Exact(0);
     PointeeSized,            sym::pointee_sized,       pointee_sized_trait,        Target::Trait,          GenericRequirement::Exact(0);
     Unsize,                  sym::unsize,              unsize_trait,               Target::Trait,          GenericRequirement::Minimum(1);
+    Alignment,               sym::Alignment,           alignment_type,             Target::Struct,         GenericRequirement::Exact(0);
     AlignOf,                 sym::mem_align_const,     align_const,                Target::AssocConst,     GenericRequirement::Exact(0);
     SizeOf,                  sym::mem_size_const,      size_const,                 Target::AssocConst,     GenericRequirement::Exact(0);
     OffsetOf,                sym::offset_of,           offset_of,                  Target::Fn,             GenericRequirement::Exact(1);

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -292,10 +292,10 @@ pub(crate) fn check_intrinsic_type(
         sym::amdgpu_dispatch_ptr => (0, 0, vec![], Ty::new_imm_ptr(tcx, tcx.types.unit)),
         sym::unreachable => (0, 0, vec![], tcx.types.never),
         sym::breakpoint => (0, 0, vec![], tcx.types.unit),
-        sym::size_of | sym::align_of | sym::variant_count => (1, 0, vec![], tcx.types.usize),
-        sym::size_of_val | sym::align_of_val => {
-            (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.usize)
-        }
+        sym::size_of | sym::variant_count => (1, 0, vec![], tcx.types.usize),
+        sym::align_of => (1, 0, vec![], tcx.ty_alignment(span)),
+        sym::size_of_val => (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.usize),
+        sym::align_of_val => (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.ty_alignment(span)),
         sym::size_of_type_id => (0, 0, vec![type_id_ty()], Ty::new_option(tcx, tcx.types.usize)),
         sym::offset_of => (1, 0, vec![tcx.types.u32, tcx.types.u32], tcx.types.usize),
         sym::field_offset => (1, 0, vec![], tcx.types.usize),

compiler/rustc_middle/src/ty/context.rs

@@ -979,6 +979,13 @@ impl<'tcx> TyCtxt<'tcx> {
         self.type_of(ordering_enum).no_bound_vars().unwrap()
     }
 
+    /// Gets a `Ty` representing the [`LangItem::Alignment`]
+    #[track_caller]
+    pub fn ty_alignment(self, span: Span) -> Ty<'tcx> {
+        let alignment = self.require_lang_item(hir::LangItem::Alignment, span);
+        self.type_of(alignment).no_bound_vars().unwrap()
+    }
+
     /// Obtain the given diagnostic item's `DefId`. Use `is_diagnostic_item` if you just want to
     /// compare against another `DefId`, since `is_diagnostic_item` is cheaper.
     pub fn get_diagnostic_item(self, name: Symbol) -> Option<DefId> {

compiler/rustc_mir_transform/src/check_alignment.rs

@@ -55,14 +55,23 @@ fn insert_alignment_check<'tcx>(
     stmts.push(Statement::new(source_info, StatementKind::Assign(Box::new((thin_ptr, rvalue)))));
 
     // Transmute the pointer to a usize (equivalent to `ptr.addr()`).
-    let rvalue = Rvalue::Cast(CastKind::Transmute, Operand::Copy(thin_ptr), tcx.types.usize);
+    let rvalue = Rvalue::Cast(CastKind::Transmute, Operand::Move(thin_ptr), tcx.types.usize);
     let addr = local_decls.push(LocalDecl::with_source_info(tcx.types.usize, source_info)).into();
     stmts.push(Statement::new(source_info, StatementKind::Assign(Box::new((addr, rvalue)))));
 
     // Get the alignment of the pointee
     let align_def_id = tcx.require_lang_item(LangItem::AlignOf, source_info.span);
+    let alignment_usize =
+        local_decls.push(LocalDecl::with_source_info(tcx.types.usize, source_info)).into();
     let alignment =
         Operand::unevaluated_constant(tcx, align_def_id, &[pointee_ty.into()], source_info.span);
+    stmts.push(Statement::new(
+        source_info,
+        StatementKind::Assign(Box::new((
+            alignment_usize,
+            Rvalue::Cast(CastKind::Transmute, alignment.clone(), tcx.types.usize),
+        ))),
+    ));
 
     // Subtract 1 from the alignment to get the alignment mask
     let alignment_mask =
@@ -76,7 +85,7 @@ fn insert_alignment_check<'tcx>(
         source_info,
         StatementKind::Assign(Box::new((
             alignment_mask,
-            Rvalue::BinaryOp(BinOp::Sub, Box::new((alignment.clone(), one))),
+            Rvalue::BinaryOp(BinOp::SubUnchecked, Box::new((Operand::Move(alignment_usize), one))),
         ))),
     ));
 
@@ -138,10 +147,10 @@ fn insert_alignment_check<'tcx>(
     // Emit a check that asserts on the alignment and otherwise triggers a
     // AssertKind::MisalignedPointerDereference.
     PointerCheck {
-        cond: Operand::Copy(is_ok),
+        cond: Operand::Move(is_ok),
         assert_kind: Box::new(AssertKind::MisalignedPointerDereference {
             required: alignment,
-            found: Operand::Copy(addr),
+            found: Operand::Move(addr),
         }),
     }
 }

library/core/src/intrinsics/mod.rs

@@ -2797,7 +2797,7 @@ pub const fn size_of<T>() -> usize;
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn align_of<T>() -> usize;
+pub const fn align_of<T>() -> mem::Alignment;
 
 /// The offset of a field inside a type.
 ///
@@ -2871,7 +2871,7 @@ pub const unsafe fn size_of_val<T: ?Sized>(ptr: *const T) -> usize;
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
 #[rustc_intrinsic_const_stable_indirect]
-pub const unsafe fn align_of_val<T: ?Sized>(ptr: *const T) -> usize;
+pub const unsafe fn align_of_val<T: ?Sized>(ptr: *const T) -> mem::Alignment;
 
 #[rustc_intrinsic]
 #[unstable(feature = "core_intrinsics", issue = "none")]