Lines Matching refs:values
330 // values 0xff and 0x00.
347 static simdutf_really_inline simd8<uint8_t> load(const uint8_t* values) { return vld1q_u8(values); }
352 simdutf_really_inline simd8(const uint8_t values[16]) : simd8(load(values)) {}
374 // Repeat 16 values as many times as necessary (usually for lookup tables)
423 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
457 static simdutf_really_inline simd8<int8_t> load(const int8_t values[16]) { return vld1q_s8(values); }
527 simdutf_really_inline simd8(const int8_t* values) : simd8(load(values)) {}
546 // Repeat 16 values as many times as necessary (usually for lookup tables)
837 static simdutf_really_inline simd16<T> load(const T values[8]) {
838 return vld1q_u16(reinterpret_cast<const uint16_t*>(values));
869 simdutf_really_inline simd16(const int16_t* values) : simd16(load(values)) {}
870 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const int16_t*>(values))) {}
896 simdutf_really_inline simd16(const uint16_t* values) : simd16(load(values)) {}
897 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const uint16_t*>(values))) {}
1153 // If the x86intrin.h header has uninitialized values that are problematic,
1570 // If the x86intrin.h header has uninitialized values that are problematic,
1761 static simdutf_really_inline simd8<T> load(const T values[32]) {
1762 return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(values));
1764 // Repeat 16 values as many times as necessary (usually for lookup tables)
1792 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
1823 simdutf_really_inline simd8(const int8_t values[32]) : simd8(load(values)) {}
1837 // Repeat 16 values as many times as necessary (usually for lookup tables)
1865 simdutf_really_inline simd8(const uint8_t values[32]) : simd8(load(values)) {}
1878 // Repeat 16 values as many times as necessary (usually for lookup tables)
2110 static simdutf_really_inline simd16<T> load(const T values[8]) {
2111 return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(values));
2138 simdutf_really_inline simd16(const int16_t* values) : simd16(load(values)) {}
2139 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const int16_t*>(values))) {}
2156 simdutf_really_inline simd16(const uint16_t* values) : simd16(load(values)) {}
2157 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const uint16_t*>(values))) {}
2500 // If the x86intrin.h header has uninitialized values that are problematic,
2667 static simdutf_really_inline simd8<T> load(const T values[16]) {
2668 return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
2670 // Repeat 16 values as many times as necessary (usually for lookup tables)
2696 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
2725 simdutf_really_inline simd8(const int8_t* values) : simd8(load(values)) {}
2734 // Repeat 16 values as many times as necessary (usually for lookup tables)
2763 simdutf_really_inline simd8(const uint8_t* values) : simd8(load(values)) {}
2772 // Repeat 16 values as many times as necessary (usually for lookup tables)
2825 static simdutf_really_inline simd8<uint16_t> load(const uint16_t values[8]) {
2826 return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
2834 simdutf_really_inline simd8(const uint16_t* values) : simd8(load(values)) {}
3059 static simdutf_really_inline simd16<T> load(const T values[8]) {
3060 return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
3087 simdutf_really_inline simd16(const int16_t* values) : simd16(load(values)) {}
3088 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const int16_t*>(values))) {}
3111 simdutf_really_inline simd16(const uint16_t* values) : simd16(load(values)) {}
3112 simdutf_really_inline simd16(const char16_t* values) : simd16(load(reinterpret_cast<const uint16_t*>(values))) {}
3117 // Repeat 16 values as many times as necessary (usually for lookup tables)
3589 static simdutf_really_inline simd8<T> load(const T values[16]) {
3590 return (__m128i)(vec_vsx_ld(0, reinterpret_cast<const uint8_t *>(values)));
3592 // Repeat 16 values as many times as necessary (usually for lookup tables)
3630 // for out of range values)
3658 simdutf_really_inline simd8(const int8_t *values) : simd8(load(values)) {}
3667 // Repeat 16 values as many times as necessary (usually for lookup tables)
3707 simdutf_really_inline simd8(const uint8_t *values) : simd8(load(values)) {}
3715 // Repeat 16 values as many times as necessary (usually for lookup tables)
13108 // 1. prepare 2-byte values
13767 2. an input register contains no surrogates and values are
13774 When values are less than 0x0800, it means that a 16-bit code unit
13788 When values fit in 16-bit code units, but are above 0x07ff, then
13797 array of 32-bit values. The array spans two SSE registers.
13852 // 1. prepare 2-byte values
14106 // 1. prepare 2-byte values
14319 2. an input register contains no surrogates and values are
14326 When values are less than 0x0800, it means that a 16-bit code unit
14340 When values fit in 16-bit code units, but are above 0x07ff, then
14349 array of 32-bit values. The array spans two SSE registers.
14561 // 1. prepare 2-byte values
14794 // 1. prepare 2-byte values
18167 // characters represented as 4-byte values. We can compute it from
18329 __m512i values;
18331 values = _mm512_and_si512(utf8, v_3f3f_3f7f);
18340 values = _mm512_maddubs_epi16(values, v_0140_0140);
18349 values = _mm512_madd_epi16(values, v_0001_1000);
18351 /* 4. Shift left the values by variable amounts to reset highest UTF-8 bits
18395 values = _mm512_sllv_epi32(values, shift);
18398 /* 5. Shift right the values by variable amounts to reset lowest bits
18417 values = _mm512_srlv_epi32(values, shift);
18420 return values;
19861 // 1. prepare 2-byte values
20106 // 1. prepare 2-byte values
22026 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
22033 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
22515 // 1. prepare 2-byte values
23035 2. an input register contains no surrogates and values are
23042 When values are less than 0x0800, it means that a 16-bit code unit
23056 When values fit in 16-bit code units, but are above 0x07ff, then
23065 array of 32-bit values. The array spans two SSE registers.
23119 // 1. prepare 2-byte values
23362 // 1. prepare 2-byte values
23567 2. an input register contains no surrogates and values are
23574 When values are less than 0x0800, it means that a 16-bit code unit
23588 When values fit in 16-bit code units, but are above 0x07ff, then
23597 array of 32-bit values. The array spans two SSE registers.
23880 // 1. prepare 2-byte values
24125 // 1. prepare 2-byte values
26885 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
26892 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
28405 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
28412 // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.
28422 * reads a vector of uint16 values
28441 // 1. prepare 2-byte values
29546 2. an input register contains no surrogates and values are
29553 When values are less than 0x0800, it means that a 16-bit code unit
29567 When values fit in 16-bit code units, but are above 0x07ff, then
29576 array of 32-bit values. The array spans two SSE registers.
30001 2. an input register contains no surrogates and values are
30008 When values are less than 0x0800, it means that a 16-bit code unit
30022 When values fit in 16-bit code units, but are above 0x07ff, then
30031 array of 32-bit values. The array spans two SSE registers.
30273 __m128i nextin = _mm_loadu_si128((__m128i*)buf+1);//These two values can hold only 8 UTF32 chars
30283 //By ensuring the highest bit is set to 0(&v_7fffffff), we're making sure all values are interpreted as non-negative, or specifically, the values are within the range of valid Unicode code points.
30340 // 1. prepare 2-byte values
30596 // 1. prepare 2-byte values