Implement layout_of_val in cg_ssa

It was already computing both anyway with `size_of_val::size_and_align_of_dst`, so we just need to return them both instead of ignoring one.

Author: scottmcm

compiler/rustc_codegen_llvm/src/lib.rs

@@ -354,8 +354,12 @@ impl CodegenBackend for LlvmCodegenBackend {
     }
 
     fn replaced_intrinsics(&self) -> Vec<Symbol> {
-        let mut will_not_use_fallback =
-            vec![sym::unchecked_funnel_shl, sym::unchecked_funnel_shr, sym::carrying_mul_add];
+        let mut will_not_use_fallback = vec![
+            sym::unchecked_funnel_shl,
+            sym::unchecked_funnel_shr,
+            sym::carrying_mul_add,
+            sym::layout_of_val,
+        ];
 
         if llvm_util::get_version() >= (22, 0, 0) {
             will_not_use_fallback.push(sym::carryless_mul);

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -1,4 +1,4 @@
-use rustc_abi::WrappingRange;
+use rustc_abi::{FieldIdx, WrappingRange};
 use rustc_middle::mir::SourceInfo;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -7,7 +7,7 @@ use rustc_span::sym;
 use rustc_target::spec::Arch;
 
 use super::FunctionCx;
-use super::operand::OperandRef;
+use super::operand::{OperandRef, OperandRefBuilder};
 use super::place::PlaceRef;
 use crate::common::{AtomicRmwBinOp, SynchronizationScope};
 use crate::errors::InvalidMonomorphization;
@@ -149,17 +149,26 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
             sym::va_start => bx.va_start(args[0].immediate()),
             sym::va_end => bx.va_end(args[0].immediate()),
-            sym::size_of_val => {
+            sym::size_of_val | sym::align_of_val | sym::layout_of_val => {
                 let tp_ty = fn_args.type_at(0);
                 let (_, meta) = args[0].val.pointer_parts();
-                let (llsize, _) = size_of_val::size_and_align_of_dst(bx, tp_ty, meta);
-                llsize
-            }
-            sym::align_of_val => {
-                let tp_ty = fn_args.type_at(0);
-                let (_, meta) = args[0].val.pointer_parts();
-                let (_, llalign) = size_of_val::size_and_align_of_dst(bx, tp_ty, meta);
-                llalign
+                let (llsize, llalign) = size_of_val::size_and_align_of_dst(bx, tp_ty, meta);
+                match name {
+                    sym::size_of_val => llsize,
+                    sym::align_of_val => llalign,
+                    sym::layout_of_val => {
+                        // Use the builder so we're insulated from the in-memory field order
+                        let mut builder = OperandRefBuilder::<'_, Bx::Value>::new(result.layout);
+                        builder.insert_imm(FieldIdx::from_u32(0), llsize);
+                        builder.insert_imm(FieldIdx::from_u32(1), llalign);
+                        let val = builder.build(bx.cx()).val;
+                        // the match can only return a single `Bx::Value`,
+                        // so we need to do the store and return.
+                        val.store(bx, result);
+                        return Ok(());
+                    }
+                    _ => bug!(),
+                }
             }
             sym::vtable_size | sym::vtable_align => {
                 let vtable = args[0].immediate();
@@ -179,9 +188,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         let size_bound = bx.data_layout().ptr_sized_integer().signed_max() as u128;
                         bx.range_metadata(value, WrappingRange { start: 0, end: size_bound });
                     }
-                    // Alignment is always nonzero.
+                    // Alignment is always a power of two, thus 1..=0x800…000.
                     sym::vtable_align => {
-                        bx.range_metadata(value, WrappingRange { start: 1, end: !0 })
+                        let align_bound = bx.data_layout().ptr_sized_integer().signed_min() as u128;
+                        bx.range_metadata(value, WrappingRange { start: 1, end: align_bound })
                     }
                     _ => {}
                 }

compiler/rustc_codegen_ssa/src/size_of_val.rs

@@ -36,8 +36,9 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             // Size is always <= isize::MAX.
             let size_bound = bx.data_layout().ptr_sized_integer().signed_max() as u128;
             bx.range_metadata(size, WrappingRange { start: 0, end: size_bound });
-            // Alignment is always nonzero.
-            bx.range_metadata(align, WrappingRange { start: 1, end: !0 });
+            // Alignment is always a power of two, thus 1..=0x800…000.
+            let align_bound = size_bound + 1;
+            bx.range_metadata(align, WrappingRange { start: 1, end: align_bound });
 
             (size, align)
         }
@@ -157,7 +158,12 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             // Furthermore, `align >= unsized_align`, and therefore we only need to do:
             // let full_size = (unsized_offset_unadjusted + unsized_size).align_to(full_align);
 
-            let full_size = bx.add(unsized_offset_unadjusted, unsized_size);
+            // This is the size *before* rounding up, which cannot exceed the size *after*
+            // rounding up, which itself cannot exceed `isize::MAX`. Thus the addition
+            // itself cannot overflow `isize::MAX`, let alone `usize::MAX`.
+            // (The range attribute from loading the size from the vtable is enough to prove
+            // `nuw`, but not `nsw`, which we only know from Rust's layout rules.)
+            let full_size = bx.unchecked_suadd(unsized_offset_unadjusted, unsized_size);
 
             // Issue #27023: must add any necessary padding to `size`
             // (to make it a multiple of `align`) before returning it.

tests/codegen-llvm/dst-vtable-align-nonzero.rs

@@ -64,4 +64,4 @@ pub unsafe fn align_load_from_vtable_align_intrinsic(x: &dyn Trait) -> usize {
     core::intrinsics::vtable_align(vtable)
 }
 
-// CHECK: [[RANGE_META]] = !{[[USIZE]] 1, [[USIZE]] 0}
+// CHECK: [[RANGE_META]] = !{[[USIZE]] 1, [[USIZE]] {{-2147483647|-9223372036854775807}}}

tests/codegen-llvm/intrinsics/layout_of_val.rs

@@ -0,0 +1,77 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z inline-mir
+//@ only-64bit (so I don't need to worry about usize)
+//@ needs-deterministic-layouts
+
+// Note that the layout algorithm currently puts the align before the size,
+// because the *type* for the size doesn't have a niche.  This test may need
+// to be updated if the in-memory field order of `Layout` ever changes.
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::alloc::Layout;
+use std::intrinsics::layout_of_val;
+
+// CHECK-LABEL: @thin_metadata(
+#[no_mangle]
+pub unsafe fn thin_metadata(ptr: *const [u32; 2]) -> Layout {
+    // CHECK: [[LAYOUT:%.+]] = alloca [16 x i8], align 8
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK: store i64 4, ptr [[LAYOUT]], align 8
+    // CHECK-NEXT: [[SIZEP:%.+]] = getelementptr inbounds i8, ptr [[LAYOUT]], i64 8
+    // CHECK-NEXT: store i64 8, ptr [[SIZEP]], align 8
+    // CHECK-NOT: store
+    layout_of_val(ptr)
+}
+
+// CHECK-LABEL: @slice_metadata(ptr noundef %ptr.0, i64 noundef %ptr.1)
+#[no_mangle]
+pub unsafe fn slice_metadata(ptr: *const [u32]) -> Layout {
+    // CHECK: [[LAYOUT:%.+]] = alloca [16 x i8], align 8
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK: [[BYTES:%.+]] = mul nuw nsw i64 %ptr.1, 4
+    // CHECK-NEXT: store i64 4, ptr [[LAYOUT]], align 8
+    // CHECK-NEXT: [[SIZEP:%.+]] = getelementptr inbounds i8, ptr [[LAYOUT]], i64 8
+    // CHECK-NEXT: store i64 [[BYTES]], ptr [[SIZEP]], align 8
+    // CHECK-NOT: store
+    layout_of_val(ptr)
+}
+
+pub struct WithTail<T: ?Sized>([u32; 3], T);
+
+// CHECK-LABEL: @dst_metadata
+// CHECK-SAME: (ptr noundef %ptr.0, ptr{{.+}}%ptr.1)
+#[no_mangle]
+pub unsafe fn dst_metadata(ptr: *const WithTail<dyn std::fmt::Debug>) -> Layout {
+    // CHECK: [[LAYOUT:%.+]] = alloca [16 x i8], align 8
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK: [[DST_SIZEP:%.+]] = getelementptr inbounds i8, ptr %ptr.1, i64 8
+    // CHECK-NEXT: [[DST_SIZE:%.+]] = load i64, ptr [[DST_SIZEP]], align 8,
+    // CHECK-SAME: !range [[SIZE_RANGE:.+]], !invariant.load
+    // CHECK-NEXT: [[DST_ALIGNP:%.+]] = getelementptr inbounds i8, ptr %ptr.1, i64 16
+    // CHECK-NEXT: [[DST_ALIGN:%.+]] = load i64, ptr [[DST_ALIGNP]], align 8,
+    // CHECK-SAME: !range [[ALIGN_RANGE:!.+]], !invariant.load
+
+    // CHECK-NEXT: [[STRUCT_MORE:%.+]] = icmp ugt i64 4, [[DST_ALIGN]]
+    // CHECK-NEXT: [[ALIGN:%.+]] = select i1 [[STRUCT_MORE]], i64 4, i64 [[DST_ALIGN]]
+
+    // CHECK-NEXT: [[MINSIZE:%.+]] = add nuw nsw i64 12, [[DST_SIZE]]
+    // CHECK-NEXT: [[ALIGN_M1:%.+]] = sub i64 [[ALIGN]], 1
+    // CHECK-NEXT: [[MAXSIZE:%.+]] = add i64 [[MINSIZE]], [[ALIGN_M1]]
+    // CHECK-NEXT: [[ALIGN_NEG:%.+]] = sub i64 0, [[ALIGN]]
+    // CHECK-NEXT: [[SIZE:%.+]] = and i64 [[MAXSIZE]], [[ALIGN_NEG]]
+
+    // CHECK-NEXT: store i64 [[ALIGN]], ptr [[LAYOUT]], align 8
+    // CHECK-NEXT: [[LAYOUT_SIZEP:%.+]] = getelementptr inbounds i8, ptr [[LAYOUT]], i64 8
+    // CHECK-NEXT: store i64 [[SIZE]], ptr [[LAYOUT_SIZEP]], align 8
+    // CHECK-NOT: store
+    layout_of_val(ptr)
+}
+
+// CHECK-LABEL: declare
+
+// CHECK: [[ALIGN_RANGE]] = !{i64 1, i64 -[[#0x7FFFFFFFFFFFFFFF]]
+// CHECK: [[SIZE_RANGE]] = !{i64 0, i64 -[[#0x8000000000000000]]