Hint that memchr returns an in-bounds index

library/core/src/slice/memchr.rs

@@ -28,7 +28,12 @@ pub const fn memchr(x: u8, text: &[u8]) -> Option<usize> {
         return memchr_naive(x, text);
     }
 
-    memchr_aligned(x, text)
+    let result = memchr_aligned(x, text);
+    if let Some(index) = result {
+        // SAFETY: `memchr_aligned` only returns the index of a matching byte in `text`.
+        unsafe { crate::hint::assert_unchecked(index < text.len()) };
+    }
+    result
 }
 
 #[inline]
@@ -107,8 +112,18 @@ const fn memchr_aligned(x: u8, text: &[u8]) -> Option<usize> {
 }
 
 /// Returns the last index matching the byte `x` in `text`.
+#[inline]
 #[must_use]
 pub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {
+    let result = memrchr_aligned(x, text);
+    if let Some(index) = result {
+        // SAFETY: `memrchr_aligned` only returns the index of a matching byte in `text`.
+        unsafe { crate::hint::assert_unchecked(index < text.len()) };
+    }
+    result
+}
+
+fn memrchr_aligned(x: u8, text: &[u8]) -> Option<usize> {
     // Scan for a single byte value by reading two `usize` words at a time.
     //
     // Split `text` in three parts:

library/coretests/tests/slice.rs

@@ -1781,6 +1781,17 @@ pub mod memchr {
         assert_eq!(None, memchr(b'a', b"xyz"));
     }
 
+    #[test]
+    fn each_alignment() {
+        let mut data = [1u8; 64];
+        let needle = 2;
+        let pos = 40;
+        data[pos] = needle;
+        for start in 0..16 {
+            assert_eq!(Some(pos - start), memchr(needle, &data[start..]));
+        }
+    }
+
     #[test]
     fn matches_one_reversed() {
         assert_eq!(Some(0), memrchr(b'a', b"a"));

tests/codegen-llvm/lib-optimizations/memchr-result.rs

@@ -0,0 +1,26 @@
+// Ensure `memchr` communicates that a returned index is in bounds.
+//@ compile-flags: -Copt-level=3 -Zinline-mir=false
+//@ only-64bit
+
+#![crate_type = "lib"]
+#![feature(slice_internals)]
+
+extern crate core;
+
+use core::slice::memchr::memrchr;
+
+// CHECK-LABEL: @find_char
+#[no_mangle]
+pub fn find_char(haystack: &str, needle: char) -> Option<usize> {
+    // CHECK-NOT: phi { i64, i64 }
+    // CHECK: ret { i64, i64 }
+    haystack.find(needle)
+}
+
+// CHECK-LABEL: @rfind_byte
+#[no_mangle]
+pub fn rfind_byte(haystack: &[u8], needle: u8) -> Option<u8> {
+    // CHECK-NOT: panic_bounds_check
+    // CHECK: ret { i1, i8 }
+    memrchr(needle, haystack).map(|index| haystack[index])
+}