Replace NullOp::SizeOf and NullOp::AlignOf by lang items.

example/example.rs

@@ -72,10 +72,6 @@ pub fn debug_tuple() -> DebugTuple {
     DebugTuple(())
 }
 
-pub fn size_of<T>() -> usize {
-    intrinsics::size_of::<T>()
-}
-
 pub fn use_size_of() -> usize {
     size_of::<u64>()
 }

example/mini_core.rs

@@ -6,6 +6,7 @@
     extern_types,
     decl_macro,
     rustc_attrs,
+    rustc_private,
     transparent_unions,
     auto_traits,
     freeze_impls,
@@ -594,7 +595,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Box<U>> for Box<T> {}
 impl<T> Box<T> {
     pub fn new(val: T) -> Box<T> {
         unsafe {
-            let size = intrinsics::size_of::<T>();
+            let size = size_of::<T>();
             let ptr = libc::malloc(size);
             intrinsics::copy(&val as *const T as *const u8, ptr, size);
             Box(Unique { pointer: NonNull(ptr as *const T), _marker: PhantomData }, Global)
@@ -646,11 +647,11 @@ pub mod intrinsics {
     #[rustc_intrinsic]
     pub fn abort() -> !;
     #[rustc_intrinsic]
-    pub fn size_of<T>() -> usize;
+    pub const fn size_of<T>() -> usize;
     #[rustc_intrinsic]
     pub unsafe fn size_of_val<T: ?::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
-    pub fn align_of<T>() -> usize;
+    pub const fn align_of<T>() -> usize;
     #[rustc_intrinsic]
     pub unsafe fn align_of_val<T: ?::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
@@ -715,6 +716,23 @@ impl<T> Index<usize> for [T] {
     }
 }
 
+pub const fn size_of<T>() -> usize {
+    <T as SizedTypeProperties>::SIZE
+}
+
+pub const fn align_of<T>() -> usize {
+    <T as SizedTypeProperties>::ALIGN
+}
+
+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>();
+}
+impl<T> SizedTypeProperties for T {}
+
 extern "C" {
     type VaListImpl;
 }

example/mini_core_hello_world.rs

@@ -109,10 +109,10 @@ fn start<T: Termination + 'static>(
             puts(*argv as *const i8);
         }
         unsafe {
-            puts(*((argv as usize + intrinsics::size_of::<*const u8>()) as *const *const i8));
+            puts(*((argv as usize + size_of::<*const u8>()) as *const *const i8));
         }
         unsafe {
-            puts(*((argv as usize + 2 * intrinsics::size_of::<*const u8>()) as *const *const i8));
+            puts(*((argv as usize + 2 * size_of::<*const u8>()) as *const *const i8));
         }
     }
 
@@ -213,8 +213,8 @@ fn main() {
         assert_eq!(intrinsics::size_of_val(a) as u8, 16);
         assert_eq!(intrinsics::size_of_val(&0u32) as u8, 4);
 
-        assert_eq!(intrinsics::align_of::<u16>() as u8, 2);
-        assert_eq!(intrinsics::align_of_val(&a) as u8, intrinsics::align_of::<&str>() as u8);
+        assert_eq!(align_of::<u16>() as u8, 2);
+        assert_eq!(intrinsics::align_of_val(&a) as u8, align_of::<&str>() as u8);
 
         let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
         assert!(!u8_needs_drop);

src/base.rs

@@ -833,8 +833,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     assert!(lval.layout().ty.is_sized(fx.tcx, fx.typing_env()));
                     let layout = fx.layout_of(fx.monomorphize(ty));
                     let val = match null_op {
-                        NullOp::SizeOf => layout.size.bytes(),
-                        NullOp::AlignOf => layout.align.bytes(),
                         NullOp::OffsetOf(fields) => fx
                             .tcx
                             .offset_of_subfield(