Skip to main content

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