Add tests for LLVM 20 slice bounds check optimization

Author: reez12g

tests/assembly/x86_64-slice-last-elements-optimization.rs

@@ -0,0 +1,48 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// This test verifies that LLVM 20 properly optimizes the assembly for
+// code that accesses the last few elements of a slice.
+// The issue fixed in LLVM 20 was that the assembly would include an unreachable
+// branch to slice_start_index_len_fail even when the bounds check was provably safe.
+
+// Check for proper assembly generation in this function:
+// asm-label: last_four_initial:
+#[no_mangle]
+pub fn last_four_initial(s: &[u8]) -> &[u8] {
+    // Previously this would generate a branch to slice_start_index_len_fail
+    // that is unreachable. The LLVM 20 fix should eliminate this branch.
+    //
+    // We should see no ".LBB" label with a call to slice_start_index_len_fail
+    //
+    // asm-not: slice_start_index_len_fail
+    let start = if s.len() <= 4 {
+        0
+    } else {
+        s.len() - 4
+    };
+    &s[start..]
+}
+
+// asm-label: last_four_optimized:
+#[no_mangle]
+pub fn last_four_optimized(s: &[u8]) -> &[u8] {
+    // This implementation has always been optimized correctly
+    // asm-not: slice_start_index_len_fail
+    if s.len() <= 4 {
+        &s[0..]
+    } else {
+        &s[s.len() - 4..]
+    }
+}
+
+// For comparison, this should still produce the branch
+// asm-label: test_bounds_check_happens:
+#[no_mangle]
+pub fn test_bounds_check_happens(s: &[u8], i: usize) -> &[u8] {
+    // asm: slice_start_index_len_fail
+    &s[i..]
+}

tests/codegen/slice-last-elements-optimization.rs

@@ -0,0 +1,48 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+#![crate_type = "lib"]
+
+// This test verifies that LLVM 20 properly optimizes the bounds check
+// when accessing the last few elements of a slice with proper conditions.
+// Previously, this would generate an unreachable branch to
+// slice_start_index_len_fail even when the bounds check was provably safe.
+
+// CHECK-LABEL: @last_four_initial(
+#[no_mangle]
+pub fn last_four_initial(s: &[u8]) -> &[u8] {
+    // In a suboptimal implementation this would contain a call to
+    // slice_start_index_len_fail that is unreachable.
+
+    // The fix exists in LLVM 20: We use this implementation with
+    // bounds check outside of slice operation.
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: unreachable
+    let start = if s.len() <= 4 {
+        0
+    } else {
+        s.len() - 4
+    };
+    &s[start..]
+}
+
+// CHECK-LABEL: @last_four_optimized(
+#[no_mangle]
+pub fn last_four_optimized(s: &[u8]) -> &[u8] {
+    // This implementation avoids the issue by moving the slice operation
+    // inside the conditional.
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: unreachable
+    if s.len() <= 4 {
+        &s[0..]
+    } else {
+        &s[s.len() - 4..]
+    }
+}
+
+// Just to verify we're correctly checking for the right thing
+// CHECK-LABEL: @test_bounds_check_happens(
+#[no_mangle]
+pub fn test_bounds_check_happens(s: &[u8], i: usize) -> &[u8] {
+    // CHECK: slice_start_index_len_fail
+    &s[i..]
+}

tests/ui/optimizations/slice-last-elements-bounds-check.rs

@@ -0,0 +1,57 @@
+//@ run-pass
+//@ compile-flags: -Copt-level=3
+
+// This test verifies that the LLVM 20 fix for slice bounds check optimization
+// correctly identifies that the bounds checks are unnecessary in patterns
+// where we access the last few elements of a slice.
+//
+// Before the fix, this code would generate an unreachable bounds check
+// that could lead to suboptimal code generation.
+
+fn last_four(s: &[u8]) -> &[u8] {
+    let start = if s.len() <= 4 {
+        0
+    } else {
+        s.len() - 4
+    };
+    &s[start..] // This should not generate an unreachable bounds check failure
+}
+
+fn last_four_optimized(s: &[u8]) -> &[u8] {
+    if s.len() <= 4 {
+        &s[0..]
+    } else {
+        &s[s.len() - 4..]
+    }
+}
+
+fn generic_last_n<T>(s: &[T], n: usize) -> &[T] {
+    let start = if s.len() <= n {
+        0
+    } else {
+        s.len() - n
+    };
+    &s[start..] // This should not generate an unreachable bounds check failure
+}
+
+fn main() {
+    // Test with different slice sizes to exercise all code paths
+    let empty: [u8; 0] = [];
+    let small = [1, 2, 3];
+    let large = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    // Test the first implementation
+    assert_eq!(last_four(&empty), &[]);
+    assert_eq!(last_four(&small), &[1, 2, 3]);
+    assert_eq!(last_four(&large), &[7, 8, 9, 10]);
+
+    // Test the optimized implementation
+    assert_eq!(last_four_optimized(&empty), &[]);
+    assert_eq!(last_four_optimized(&small), &[1, 2, 3]);
+    assert_eq!(last_four_optimized(&large), &[7, 8, 9, 10]);
+
+    // Test the generic implementation
+    assert_eq!(generic_last_n(&empty, 2), &[]);
+    assert_eq!(generic_last_n(&small, 2), &[2, 3]);
+    assert_eq!(generic_last_n(&large, 5), &[6, 7, 8, 9, 10]);
+}