Add range information to slice metadata for types that are known to not be ZST

This uses a conservative approximation since the layout of the pointee
is not always available when computing the metadata layout.

Author: the8472

compiler/rustc_middle/src/ty/sty.rs

@@ -2842,6 +2842,34 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    pub fn is_trivially_non_zst(self, tcx: TyCtxt<'tcx>) -> bool {
+        match self.kind() {
+            ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+            | ty::Uint(_)
+            | ty::Int(_)
+            | ty::Bool
+            | ty::Float(_)
+            | ty::FnPtr(_)
+            | ty::RawPtr(..)
+            | ty::Char
+            | ty::Ref(..)
+            | ty::Closure(..) => true,
+            ty::Array(ty, len) => {
+                if let Some(len) = len.try_to_target_usize(tcx) {
+                    return len > 0 && ty.is_trivially_non_zst(tcx);
+                }
+                false
+            }
+            ty::Tuple(tys) => tys.iter().any(|ty| ty.is_trivially_non_zst(tcx)),
+            ty::Adt(def, args) => def.all_fields().any(|field| {
+                let ty = field.ty(tcx, args);
+                ty.is_trivially_non_zst(tcx)
+            }),
+
+            _ => false,
+        }
+    }
+
     /// Fast path helper for primitives which are always `Copy` and which
     /// have a side-effect-free `Clone` impl.
     ///

compiler/rustc_ty_utils/src/layout.rs

@@ -200,10 +200,24 @@ fn layout_of_uncached<'tcx>(
                     return Ok(tcx.mk_layout(LayoutS::scalar(cx, data_ptr)));
                 }
 
-                let Abi::Scalar(metadata) = metadata_layout.abi else {
+                let Abi::Scalar(mut metadata) = metadata_layout.abi else {
                     return Err(error(cx, LayoutError::Unknown(pointee)));
                 };
 
+                if !ty.is_unsafe_ptr() {
+                    match pointee.kind() {
+                        ty::Slice(element) => {
+                            if element.is_trivially_non_zst(tcx) {
+                                metadata.valid_range_mut().end = dl.ptr_sized_integer().signed_max() as u128;
+                            }
+                        },
+                        ty::Str => {
+                            metadata.valid_range_mut().end = dl.ptr_sized_integer().signed_max() as u128;
+                        }
+                        _ => {}
+                    }
+                }
+
                 metadata
             } else {
                 let unsized_part = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
@@ -212,7 +226,18 @@ fn layout_of_uncached<'tcx>(
                     ty::Foreign(..) => {
                         return Ok(tcx.mk_layout(LayoutS::scalar(cx, data_ptr)));
                     }
-                    ty::Slice(_) | ty::Str => scalar_unit(Int(dl.ptr_sized_integer(), false)),
+                    ty::Slice(element) => {
+                        let mut metadata = scalar_unit(Int(dl.ptr_sized_integer(), false));
+                        if !ty.is_unsafe_ptr() && !element.is_trivially_non_zst(tcx) {
+                            metadata.valid_range_mut().end = dl.ptr_sized_integer().signed_max() as u128;
+                        }
+                        metadata
+                    },
+                    ty::Str => {
+                        let mut metadata = scalar_unit(Int(dl.ptr_sized_integer(), false));
+                        metadata.valid_range_mut().end = dl.ptr_sized_integer().signed_max() as u128;
+                        metadata
+                    },
                     ty::Dynamic(..) => {
                         let mut vtable = scalar_unit(Pointer(AddressSpace::DATA));
                         vtable.valid_range_mut().start = 1;

tests/codegen/intrinsics/transmute.rs

@@ -372,9 +372,11 @@ pub unsafe fn check_issue_110005(x: (usize, bool)) -> Option<Box<[u8]>> {
 #[no_mangle]
 pub unsafe fn check_pair_to_dst_ref<'a>(x: (usize, usize)) -> &'a [u8] {
     // CHECK: %_0.0 = inttoptr i64 %x.0 to ptr
-    // CHECK: %0 = insertvalue { ptr, i64 } poison, ptr %_0.0, 0
-    // CHECK: %1 = insertvalue { ptr, i64 } %0, i64 %x.1, 1
-    // CHECK: ret { ptr, i64 } %1
+    // CHECK: %0 = icmp ule i64 %x.1, 9223372036854775807
+    // CHECK: call void @llvm.assume(i1 %0)
+    // CHECK: %1 = insertvalue { ptr, i64 } poison, ptr %_0.0, 0
+    // CHECK: %2 = insertvalue { ptr, i64 } %1, i64 %x.1, 1
+    // CHECK: ret { ptr, i64 } %2
     transmute(x)
 }
 

tests/codegen/slice-len.rs

@@ -0,0 +1,14 @@
+// ignore-debug: the debug assertions get in the way
+// compile-flags: -O
+// min-llvm-version: 16
+#![crate_type = "lib"]
+
+// check that slice.len() has range metadata
+
+// CHECK-LABEL: @slice_len
+#[no_mangle]
+pub fn slice_len(slice: &&[i32]) -> usize {
+    // CHECK: load {{.*}} !range
+    slice.len()
+    // CHECK: ret
+}