Skip to main content

simdutf8/implementation/portable/
simd128.rs

1//! Contains the portable SIMD UTF-8 validation implementation.
2
3#![allow(clippy::too_many_arguments)]
4#![allow(clippy::needless_pass_by_value, clippy::pedantic, clippy::all)]
5use crate::implementation::helpers::Utf8CheckAlgorithm;
6use core::simd::prelude::*;
7use core::simd::{simd_swizzle, u8x16};
8
9// Portable SIMD primitives
10type SimdU8Value = crate::implementation::helpers::SimdU8Value<u8x16>;
11
12impl SimdU8Value {
13    #[inline]
14    fn from_32_cut_off_leading(
15        _v0: u8,
16        _v1: u8,
17        _v2: u8,
18        _v3: u8,
19        _v4: u8,
20        _v5: u8,
21        _v6: u8,
22        _v7: u8,
23        _v8: u8,
24        _v9: u8,
25        _v10: u8,
26        _v11: u8,
27        _v12: u8,
28        _v13: u8,
29        _v14: u8,
30        _v15: u8,
31        v16: u8,
32        v17: u8,
33        v18: u8,
34        v19: u8,
35        v20: u8,
36        v21: u8,
37        v22: u8,
38        v23: u8,
39        v24: u8,
40        v25: u8,
41        v26: u8,
42        v27: u8,
43        v28: u8,
44        v29: u8,
45        v30: u8,
46        v31: u8,
47    ) -> Self {
48        Self::from(u8x16::from_array([
49            v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
50        ]))
51    }
52
53    #[inline]
54    fn repeat_16(
55        v0: u8,
56        v1: u8,
57        v2: u8,
58        v3: u8,
59        v4: u8,
60        v5: u8,
61        v6: u8,
62        v7: u8,
63        v8: u8,
64        v9: u8,
65        v10: u8,
66        v11: u8,
67        v12: u8,
68        v13: u8,
69        v14: u8,
70        v15: u8,
71    ) -> Self {
72        Self::from(u8x16::from_array([
73            v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
74        ]))
75    }
76
77    #[inline]
78    unsafe fn load_from(ptr: *const u8) -> Self {
79        Self::from(ptr.cast::<u8x16>().read_unaligned())
80    }
81
82    #[inline]
83    fn lookup_16(self, tbl: Self) -> Self {
84        // We need to ensure that 'self' only contains the lower 4 bits, unlike the avx instruction
85        // this will otherwise lead to bad results
86        let idx: u8x16 = self.0;
87        let src: u8x16 = tbl.0;
88        let res = src.swizzle_dyn(idx);
89        Self::from(res)
90    }
91
92    #[inline]
93    fn splat(val: u8) -> Self {
94        #[allow(clippy::cast_possible_wrap)]
95        Self::from(u8x16::splat(val))
96    }
97
98    #[inline]
99    fn splat0() -> Self {
100        Self::from(u8x16::splat(0))
101    }
102
103    #[inline]
104    fn or(self, b: Self) -> Self {
105        Self::from(self.0 | b.0)
106    }
107
108    #[inline]
109    fn and(self, b: Self) -> Self {
110        Self::from(self.0 & b.0)
111    }
112
113    #[inline]
114    fn xor(self, b: Self) -> Self {
115        Self::from(self.0 ^ b.0)
116    }
117
118    #[inline]
119    fn saturating_sub(self, b: Self) -> Self {
120        Self::from(self.0.saturating_sub(b.0))
121    }
122
123    // ugly but shr<N> requires const generics
124    #[inline]
125    fn shr4(self) -> Self {
126        Self::from(self.0 >> 4)
127    }
128
129    #[inline]
130    fn prev1(self, prev: Self) -> Self {
131        Self::from(simd_swizzle!(
132            self.0,
133            prev.0,
134            [31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,]
135        ))
136    }
137
138    // ugly but prev<N> requires const generics
139    #[inline]
140    fn prev2(self, prev: Self) -> Self {
141        Self::from(simd_swizzle!(
142            self.0,
143            prev.0,
144            [30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,]
145        ))
146    }
147
148    // ugly but prev<N> requires const generics
149    #[inline]
150    fn prev3(self, prev: Self) -> Self {
151        Self::from(simd_swizzle!(
152            self.0,
153            prev.0,
154            [29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,]
155        ))
156    }
157
158    #[inline]
159    fn any_bit_set(self) -> bool {
160        if HAS_FAST_REDUCE_MAX {
161            self.0.reduce_max() != 0
162        } else {
163            self.0 != u8x16::splat(0)
164        }
165    }
166
167    #[inline]
168    fn is_ascii(self) -> bool {
169        if HAS_FAST_REDUCE_MAX {
170            self.0.reduce_max() < 0b1000_0000
171        } else {
172            (self.0 & u8x16::splat(0b1000_0000)) == u8x16::splat(0)
173        }
174    }
175}
176
177impl From<u8x16> for SimdU8Value {
178    #[inline]
179    fn from(val: u8x16) -> Self {
180        Self(val)
181    }
182}
183
184#[inline]
185unsafe fn simd_prefetch(_ptr: *const u8) {}
186
187#[cfg(all(
188    any(target_arch = "aarch64", target_arch = "arm"),
189    target_feature = "neon"
190))]
191const HAS_FAST_REDUCE_MAX: bool = true;
192
193#[cfg(not(all(
194    any(target_arch = "aarch64", target_arch = "arm"),
195    target_feature = "neon"
196)))]
197const HAS_FAST_REDUCE_MAX: bool = false;
198
199const PREFETCH: bool = false;
200use crate::implementation::helpers::TempSimdChunkA16 as TempSimdChunk;
201simd_input_128_bit!();
202algorithm_simd!();
203algorithm_simd_default_special_case_fns!();