1 // Original implementation taken from rust-memchr.
2 // Copyright 2015 Andrew Gallant, bluss and Nicolas Koch
8 const LO_USIZE: usize = usize::repeat_u8(0x01);
9 const HI_USIZE: usize = usize::repeat_u8(0x80);
10 const USIZE_BYTES: usize = mem::size_of::<usize>();
12 /// Returns `true` if `x` contains any zero byte.
14 /// From *Matters Computational*, J. Arndt:
16 /// "The idea is to subtract one from each of the bytes and then look for
17 /// bytes where the borrow propagated all the way to the most significant
20 fn contains_zero_byte(x: usize) -> bool {
21 x.wrapping_sub(LO_USIZE) & !x & HI_USIZE != 0
24 #[cfg(target_pointer_width = "16")]
26 fn repeat_byte(b: u8) -> usize {
27 (b as usize) << 8 | b as usize
30 #[cfg(not(target_pointer_width = "16"))]
32 fn repeat_byte(b: u8) -> usize {
33 (b as usize) * (usize::MAX / 255)
36 /// Returns the first index matching the byte `x` in `text`.
39 pub const fn memchr(x: u8, text: &[u8]) -> Option<usize> {
41 fn rt_impl(x: u8, text: &[u8]) -> Option<usize> {
42 // Fast path for small slices
43 if text.len() < 2 * USIZE_BYTES {
44 return text.iter().position(|elt| *elt == x);
47 memchr_general_case(x, text)
50 const fn const_impl(x: u8, bytes: &[u8]) -> Option<usize> {
52 while i < bytes.len() {
62 // SAFETY: The const and runtime versions have identical behavior
63 unsafe { intrinsics::const_eval_select((x, text), const_impl, rt_impl) }
66 fn memchr_general_case(x: u8, text: &[u8]) -> Option<usize> {
67 // Scan for a single byte value by reading two `usize` words at a time.
69 // Split `text` in three parts
70 // - unaligned initial part, before the first word aligned address in text
71 // - body, scan by 2 words at a time
72 // - the last remaining part, < 2 word size
74 // search up to an aligned boundary
76 let ptr = text.as_ptr();
77 let mut offset = ptr.align_offset(USIZE_BYTES);
80 offset = cmp::min(offset, len);
81 if let Some(index) = text[..offset].iter().position(|elt| *elt == x) {
86 // search the body of the text
87 let repeated_x = repeat_byte(x);
88 while offset <= len - 2 * USIZE_BYTES {
89 // SAFETY: the while's predicate guarantees a distance of at least 2 * usize_bytes
90 // between the offset and the end of the slice.
92 let u = *(ptr.add(offset) as *const usize);
93 let v = *(ptr.add(offset + USIZE_BYTES) as *const usize);
95 // break if there is a matching byte
96 let zu = contains_zero_byte(u ^ repeated_x);
97 let zv = contains_zero_byte(v ^ repeated_x);
102 offset += USIZE_BYTES * 2;
105 // Find the byte after the point the body loop stopped.
106 text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i)
109 /// Returns the last index matching the byte `x` in `text`.
111 pub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {
112 // Scan for a single byte value by reading two `usize` words at a time.
114 // Split `text` in three parts:
115 // - unaligned tail, after the last word aligned address in text,
116 // - body, scanned by 2 words at a time,
117 // - the first remaining bytes, < 2 word size.
118 let len = text.len();
119 let ptr = text.as_ptr();
122 let (min_aligned_offset, max_aligned_offset) = {
123 // We call this just to obtain the length of the prefix and suffix.
124 // In the middle we always process two chunks at once.
125 // SAFETY: transmuting `[u8]` to `[usize]` is safe except for size differences
126 // which are handled by `align_to`.
127 let (prefix, _, suffix) = unsafe { text.align_to::<(Chunk, Chunk)>() };
128 (prefix.len(), len - suffix.len())
131 let mut offset = max_aligned_offset;
132 if let Some(index) = text[offset..].iter().rposition(|elt| *elt == x) {
133 return Some(offset + index);
136 // Search the body of the text, make sure we don't cross min_aligned_offset.
137 // offset is always aligned, so just testing `>` is sufficient and avoids possible
139 let repeated_x = repeat_byte(x);
140 let chunk_bytes = mem::size_of::<Chunk>();
142 while offset > min_aligned_offset {
143 // SAFETY: offset starts at len - suffix.len(), as long as it is greater than
144 // min_aligned_offset (prefix.len()) the remaining distance is at least 2 * chunk_bytes.
146 let u = *(ptr.offset(offset as isize - 2 * chunk_bytes as isize) as *const Chunk);
147 let v = *(ptr.offset(offset as isize - chunk_bytes as isize) as *const Chunk);
149 // Break if there is a matching byte.
150 let zu = contains_zero_byte(u ^ repeated_x);
151 let zv = contains_zero_byte(v ^ repeated_x);
156 offset -= 2 * chunk_bytes;
159 // Find the byte before the point the body loop stopped.
160 text[..offset].iter().rposition(|elt| *elt == x)