Lines Matching refs:value
266 uint8x16_t value;
267 static const int SIZE = sizeof(value);
270 simdutf_really_inline base_u8(const uint8x16_t _value) : value(_value) {}
271 simdutf_really_inline operator const uint8x16_t&() const { return this->value; }
272 simdutf_really_inline operator uint8x16_t&() { return this->value; }
423 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
453 int8x16_t value;
465 // mov v0.16b, value[0]
467 // mov v0.16b, value[1]
473 ? int8x16x2_t{{this->value, vmovq_n_s8(0)}}
474 : int8x16x2_t{{vmovq_n_s8(0), this->value}};
487 const uint16x8_t low = vreinterpretq_u16_s8(vzip1q_s8(this->value, vmovq_n_s8(0)));
488 const uint16x8_t high = vreinterpretq_u16_s8(vzip2q_s8(this->value, vmovq_n_s8(0)));
515 simdutf_really_inline simd8(const int8x16_t _value) : value{_value} {}
516 simdutf_really_inline operator const int8x16_t&() const { return this->value; }
518 simdutf_really_inline operator const uint8x16_t() const { return vreinterpretq_u8_s8(this->value); }
520 simdutf_really_inline operator int8x16_t&() { return this->value; }
558 simdutf_really_inline void store(int8_t dst[16]) const { return vst1q_s8(dst, value); }
567 simdutf_really_inline operator simd8<uint8_t>() const { return vreinterpretq_u8_s8(this->value); }
569 simdutf_really_inline simd8<int8_t> operator|(const simd8<int8_t> other) const { return vorrq_s8(value, other.value); }
570 simdutf_really_inline simd8<int8_t> operator&(const simd8<int8_t> other) const { return vandq_s8(value, other.value); }
571 simdutf_really_inline simd8<int8_t> operator^(const simd8<int8_t> other) const { return veorq_s8(value, other.value); }
572 simdutf_really_inline simd8<int8_t> bit_andnot(const simd8<int8_t> other) const { return vbicq_s8(value, other.value); }
575 simdutf_really_inline simd8<int8_t> operator+(const simd8<int8_t> other) const { return vaddq_s8(value, other.value); }
576 simdutf_really_inline simd8<int8_t> operator-(const simd8<int8_t> other) const { return vsubq_s8(value, other.value); }
580 simdutf_really_inline int8_t max_val() const { return vmaxvq_s8(value); }
581 simdutf_really_inline int8_t min_val() const { return vminvq_s8(value); }
585 simdutf_really_inline simd8<int8_t> max_val(const simd8<int8_t> other) const { return vmaxq_s8(value, other.value); }
586 simdutf_really_inline simd8<int8_t> min_val(const simd8<int8_t> other) const { return vminq_s8(value, other.value); }
587 simdutf_really_inline simd8<bool> operator>(const simd8<int8_t> other) const { return vcgtq_s8(value, other.value); }
588 simdutf_really_inline simd8<bool> operator<(const simd8<int8_t> other) const { return vcltq_s8(value, other.value); }
589 simdutf_really_inline simd8<bool> operator==(const simd8<int8_t> other) const { return vceqq_s8(value, other.value); }
596 // Perform a lookup assuming no value is larger than 16
777 uint16x8_t value;
778 static const int SIZE = sizeof(value);
782 simdutf_really_inline base_u16(const uint16x8_t _value) : value(_value) {}
783 simdutf_really_inline operator const uint16x8_t&() const { return this->value; }
784 simdutf_really_inline operator uint16x8_t&() { return this->value; }
813 static const int SIZE = sizeof(base_u16<T>::value);
872 simdutf_really_inline operator const uint16x8_t&() const { return this->value; }
873 simdutf_really_inline operator const int16x8_t() const { return vreinterpretq_s16_u16(this->value); }
875 simdutf_really_inline int16_t max_val() const { return vmaxvq_s16(vreinterpretq_s16_u16(this->value)); }
876 simdutf_really_inline int16_t min_val() const { return vminvq_s16(vreinterpretq_s16_u16(this->value)); }
878 simdutf_really_inline simd16<int16_t> max_val(const simd16<int16_t> other) const { return vmaxq_s16(vreinterpretq_s16_u16(this->value), vreinterpretq_s16_u16(other.value)); }
879 simdutf_really_inline simd16<int16_t> min_val(const simd16<int16_t> other) const { return vmaxq_s16(vreinterpretq_s16_u16(this->value), vreinterpretq_s16_u16(other.value)); }
880 simdutf_really_inline simd16<bool> operator>(const simd16<int16_t> other) const { return vcgtq_s16(vreinterpretq_s16_u16(this->value), vreinterpretq_s16_u16(other.value)); }
881 simdutf_really_inline simd16<bool> operator<(const simd16<int16_t> other) const { return vcltq_s16(vreinterpretq_s16_u16(this->value), vreinterpretq_s16_u16(other.value)); }
940 simdutf_really_inline simd16<int16_t>::operator simd16<uint16_t>() const { return this->value; }
1678 __m256i value;
1681 simdutf_really_inline base() : value{__m256i()} {}
1684 simdutf_really_inline base(const __m256i _value) : value(_value) {}
1686 simdutf_really_inline operator const __m256i&() const { return this->value; }
1687 simdutf_really_inline operator __m256i&() { return this->value; }
1732 static const int SIZE = sizeof(base<T>::value);
1792 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
1923 // e.g. value.get_bit<7>() gets the high bit
1927 simdutf_really_inline simd8<int8_t>::operator simd8<uint8_t>() const { return this->value; }
2080 static const int SIZE = sizeof(base<simd16<T>>::value);
2190 // e.g. value.get_bit<7>() gets the high bit
2584 __m128i value;
2587 simdutf_really_inline base() : value{__m128i()} {}
2590 simdutf_really_inline base(const __m128i _value) : value(_value) {}
2592 simdutf_really_inline operator const __m128i&() const { return this->value; }
2593 simdutf_really_inline operator __m128i&() { return this->value; }
2638 static const int SIZE = sizeof(base<simd8<T>>::value);
2696 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
2815 // e.g. value.get_bit<7>() gets the high bit
2819 simdutf_really_inline simd8<int8_t>::operator simd8<uint8_t>() const { return this->value; }
3032 static const int SIZE = sizeof(base<simd16<T>>::value);
3155 // e.g. value.get_bit<7>() gets the high bit
3170 simdutf_really_inline simd16<int16_t>::operator simd16<uint16_t>() const { return this->value; }
3473 __m128i value;
3476 simdutf_really_inline base() : value{__m128i()} {}
3479 simdutf_really_inline base(const __m128i _value) : value(_value) {}
3483 return this->value;
3485 simdutf_really_inline operator __m128i &() { return this->value; }
3489 return vec_or(this->value, (__m128i)other);
3492 return vec_and(this->value, (__m128i)other);
3495 return vec_xor(this->value, (__m128i)other);
3498 return vec_andc(this->value, (__m128i)other);
3529 return (__m128i)vec_cmpeq(lhs.value, (__m128i)rhs);
3532 static const int SIZE = sizeof(base<simd8<T>>::value);
3536 __m128i chunk = this->value;
3538 chunk = (__m128i)vec_reve(this->value);
3567 result = ((__vector unsigned long long)vec_vbpermq((__m128i)this->value,
3576 return !vec_all_eq(this->value, (__m128i)vec_splats(0));
3579 return this->value ^ (__m128i)splat(true);
3584 static simdutf_really_inline simd8<T> splat(T value) {
3585 (void)value;
3586 return (__m128i)vec_splats(value);
3607 vec_vsx_st(this->value, 0, reinterpret_cast<__m128i *>(dst));
3615 return (__m128i)((__m128i)this->value + (__m128i)other);
3618 return (__m128i)((__m128i)this->value - (__m128i)other);
3629 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
3633 return (__m128i)vec_perm((__m128i)lookup_table, (__m128i)lookup_table, this->value);
3679 return (__m128i)vec_max((__vector signed char)this->value,
3684 return (__m128i)vec_min((__vector signed char)this->value,
3689 return (__m128i)vec_cmpgt((__vector signed char)this->value,
3694 return (__m128i)vec_cmplt((__vector signed char)this->value,
3728 return (__m128i)vec_adds(this->value, (__m128i)other);
3732 return (__m128i)vec_subs(this->value, (__m128i)other);
3738 return (__m128i)vec_max(this->value, (__m128i)other);
3742 return (__m128i)vec_min(this->value, (__m128i)other);
3773 return (__m128i)vec_cmpeq(this->value, (__m128i)vec_splats(uint8_t(0)));
3790 return vec_all_eq(this->value, (__m128i)vec_splats(0));
3796 return vec_all_eq(vec_and(this->value, (__m128i)bits),
3804 (__m128i)vec_sr(this->value, (__m128i)vec_splat_u8(N)));
3808 (__m128i)vec_sl(this->value, (__m128i)vec_splat_u8(N)));
11108 uint32_t value = (diff << 10) + diff2 + 0x10000;
11111 *utf8_output++ = char((value>>18) | 0b11110000);
11112 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
11113 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
11114 *utf8_output++ = char((value & 0b111111) | 0b10000000);
11183 uint32_t value = (diff << 10) + diff2 + 0x10000;
11186 *utf8_output++ = char((value>>18) | 0b11110000);
11187 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
11188 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
11189 *utf8_output++ = char((value & 0b111111) | 0b10000000);
11242 uint32_t value = (diff << 10) + diff2 + 0x10000;
11245 *utf8_output++ = char((value>>18) | 0b11110000);
11246 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
11247 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
11248 *utf8_output++ = char((value & 0b111111) | 0b10000000);
11289 uint32_t value = (diff << 10) + diff2 + 0x10000;
11290 *utf32_output++ = char32_t(value);
11332 uint32_t value = (diff << 10) + diff2 + 0x10000;
11333 *utf32_output++ = char32_t(value);
11359 uint32_t value = (diff << 10) + diff2 + 0x10000;
11360 *utf32_output++ = char32_t(value);
11658 * If the error is believed to have occured prior to 'buf', the count value contain in the result
11937 * If the error is believed to have occured prior to 'buf', the count value contain in the result
13765 1. an input register contains no surrogates and each value
14043 uint32_t value = (diff << 10) + diff2 + 0x10000;
14044 *utf8_output++ = char((value>>18) | 0b11110000);
14045 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
14046 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
14047 *utf8_output++ = char((value & 0b111111) | 0b10000000);
14297 uint32_t value = (diff << 10) + diff2 + 0x10000;
14298 *utf8_output++ = char((value>>18) | 0b11110000);
14299 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
14300 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
14301 *utf8_output++ = char((value & 0b111111) | 0b10000000);
14317 1. an input register contains no surrogates and each value
14404 uint32_t value = (diff << 10) + diff2 + 0x10000;
14405 *utf32_output++ = char32_t(value);
14462 uint32_t value = (diff << 10) + diff2 + 0x10000;
14463 *utf32_output++ = char32_t(value);
15355 // or a byte value too large in the last bytes: check_special_cases only checks for bytes
18124 keep the value in a (constant) register.
18199 keep the value in a (constant) register.
18310 assume their value.
18611 constexpr bool UTF32 = std::is_same<OUTPUT, uint32_t>::value;
18612 constexpr bool UTF16 = std::is_same<OUTPUT, char16_t>::value;
18827 // or a byte value too large in the last bytes: check_special_cases only checks for bytes
18910 constexpr bool UTF32 = std::is_same<OUTPUT, uint32_t>::value;
18911 constexpr bool UTF16 = std::is_same<OUTPUT, char16_t>::value;
19033 constexpr bool UTF32 = std::is_same<OUTPUT, uint32_t>::value;
19034 constexpr bool UTF16 = std::is_same<OUTPUT, char16_t>::value;
20511 upscale the bytes to 16-bit value, adding the 0b11000000 leading byte in the process.
22236 value of the preceding nibble determines what we have:
22768 // the corresponding 32-bit value in 'composed' will be greater than
23033 1. an input register contains no surrogates and each value
23303 uint32_t value = (diff << 10) + diff2 + 0x10000;
23304 *utf8_output++ = char((value>>18) | 0b11110000);
23305 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
23306 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
23307 *utf8_output++ = char((value & 0b111111) | 0b10000000);
23546 uint32_t value = (diff << 10) + diff2 + 0x10000;
23547 *utf8_output++ = char((value>>18) | 0b11110000);
23548 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
23549 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
23550 *utf8_output++ = char((value & 0b111111) | 0b10000000);
23565 1. an input register contains no surrogates and each value
23664 uint32_t value = (diff << 10) + diff2 + 0x10000;
23665 *utf32_output++ = char32_t(value);
23732 uint32_t value = (diff << 10) + diff2 + 0x10000;
23733 *utf32_output++ = char32_t(value);
24766 // or a byte value too large in the last bytes: check_special_cases only checks for bytes
27138 // or a byte value too large in the last bytes: check_special_cases only checks for bytes
28713 value of the preceding nibble determines what we have:
29019 // assuming a/b are bytes and A/B are uint16 of the same value
29040 // assuming a/b are bytes and A/B are uint16 of the same value
29245 // the corresponding 32-bit value in 'composed' will be greater than
29544 1. an input register contains no surrogates and each value
29775 uint32_t value = (diff << 10) + diff2 + 0x10000;
29776 *utf8_output++ = char((value>>18) | 0b11110000);
29777 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
29778 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
29779 *utf8_output++ = char((value & 0b111111) | 0b10000000);
29979 uint32_t value = (diff << 10) + diff2 + 0x10000;
29980 *utf8_output++ = char((value>>18) | 0b11110000);
29981 *utf8_output++ = char(((value>>12) & 0b111111) | 0b10000000);
29982 *utf8_output++ = char(((value>>6) & 0b111111) | 0b10000000);
29983 *utf8_output++ = char((value & 0b111111) | 0b10000000);
29999 1. an input register contains no surrogates and each value
30097 uint32_t value = (diff << 10) + diff2 + 0x10000;
30098 *utf32_output++ = char32_t(value);
30165 uint32_t value = (diff << 10) + diff2 + 0x10000;
30166 *utf32_output++ = char32_t(value);
31145 // or a byte value too large in the last bytes: check_special_cases only checks for bytes