| 1 |
// Copyright 2022 Google LLC |
| 2 |
// |
| 3 |
// Use of this source code is governed by an MIT-style |
| 4 |
// license that can be found in the LICENSE file or at |
| 5 |
// https://opensource.org/licenses/MIT. |
| 6 |
|
| 7 |
/* This is a wrapper for the Google range-sse.cc algorithm which checks whether a |
| 8 |
* sequence of bytes is a valid UTF-8 sequence and finds the longest valid prefix of |
| 9 |
* the UTF-8 sequence. |
| 10 |
* |
| 11 |
* The key difference is that it checks for as much ASCII symbols as possible |
| 12 |
* and then falls back to the range-sse.cc algorithm. The changes to the |
| 13 |
* algorithm are cosmetic, mostly to trick the clang compiler to produce optimal |
| 14 |
* code. |
| 15 |
* |
| 16 |
* For API see the utf8_validity.h header. |
| 17 |
*/ |
| 18 |
#include "utf8_validity.h" |
| 19 |
|
| 20 |
#include <cstddef> |
| 21 |
#include <cstdint> |
| 22 |
|
| 23 |
#include "absl/strings/ascii.h" |
| 24 |
#include "absl/strings/string_view.h" |
| 25 |
|
| 26 |
#ifdef __SSE4_1__ |
| 27 |
#include <emmintrin.h> |
| 28 |
#include <smmintrin.h> |
| 29 |
#include <tmmintrin.h> |
| 30 |
#endif |
| 31 |
|
| 32 |
namespace utf8_range { |
| 33 |
namespace { |
| 34 |
|
| 35 |
inline uint64_t UNALIGNED_LOAD64(const void* p) { |
| 36 |
uint64_t t; |
| 37 |
memcpy(&t, p, sizeof t); |
| 38 |
return t; |
| 39 |
} |
| 40 |
|
| 41 |
inline bool TrailByteOk(const char c) { |
| 42 |
return static_cast<int8_t>(c) <= static_cast<int8_t>(0xBF); |
| 43 |
} |
| 44 |
|
| 45 |
/* If ReturnPosition is false then it returns 1 if |data| is a valid utf8 |
| 46 |
* sequence, otherwise returns 0. |
| 47 |
* If ReturnPosition is set to true, returns the length in bytes of the prefix |
| 48 |
of |data| that is all structurally valid UTF-8. |
| 49 |
*/ |
| 50 |
template <bool ReturnPosition> |
| 51 |
size_t ValidUTF8Span(const char* data, const char* end) { |
| 52 |
/* We return err_pos in the loop which is always 0 if !ReturnPosition */ |
| 53 |
size_t err_pos = 0; |
| 54 |
size_t codepoint_bytes = 0; |
| 55 |
/* The early check is done because of early continue's on codepoints of all |
| 56 |
* sizes, i.e. we first check for ascii and if it is, we call continue, then |
| 57 |
* for 2 byte codepoints, etc. This is done in order to reduce indentation and |
| 58 |
* improve readability of the codepoint validity check. |
| 59 |
*/ |
| 60 |
while (data + codepoint_bytes < end) { |
| 61 |
if (ReturnPosition) { |
| 62 |
err_pos += codepoint_bytes; |
| 63 |
} |
| 64 |
data += codepoint_bytes; |
| 65 |
const size_t len = end - data; |
| 66 |
const unsigned char byte1 = data[0]; |
| 67 |
|
| 68 |
/* We do not skip many ascii bytes at the same time as this function is |
| 69 |
used for tail checking (< 16 bytes) and for non x86 platforms. We also |
| 70 |
don't think that cases where non-ASCII codepoints are followed by ascii |
| 71 |
happen often. For small strings it also introduces some penalty. For |
| 72 |
purely ascii UTF8 strings (which is the overwhelming case) we call |
| 73 |
SkipAscii function which is multiplatform and extremely fast. |
| 74 |
*/ |
| 75 |
/* [00..7F] ASCII -> 1 byte */ |
| 76 |
if (absl::ascii_isascii(byte1)) { |
| 77 |
codepoint_bytes = 1; |
| 78 |
continue; |
| 79 |
} |
| 80 |
/* [C2..DF], [80..BF] -> 2 bytes */ |
| 81 |
if (len >= 2 && byte1 >= 0xC2 && byte1 <= 0xDF && TrailByteOk(data[1])) { |
| 82 |
codepoint_bytes = 2; |
| 83 |
continue; |
| 84 |
} |
| 85 |
if (len >= 3) { |
| 86 |
const unsigned char byte2 = data[1]; |
| 87 |
const unsigned char byte3 = data[2]; |
| 88 |
|
| 89 |
/* Is byte2, byte3 between [0x80, 0xBF] |
| 90 |
* Check for 0x80 was done above. |
| 91 |
*/ |
| 92 |
if (!TrailByteOk(byte2) || !TrailByteOk(byte3)) { |
| 93 |
return err_pos; |
| 94 |
} |
| 95 |
|
| 96 |
if (/* E0, A0..BF, 80..BF */ |
| 97 |
((byte1 == 0xE0 && byte2 >= 0xA0) || |
| 98 |
/* E1..EC, 80..BF, 80..BF */ |
| 99 |
(byte1 >= 0xE1 && byte1 <= 0xEC) || |
| 100 |
/* ED, 80..9F, 80..BF */ |
| 101 |
(byte1 == 0xED && byte2 <= 0x9F) || |
| 102 |
/* EE..EF, 80..BF, 80..BF */ |
| 103 |
(byte1 >= 0xEE && byte1 <= 0xEF))) { |
| 104 |
codepoint_bytes = 3; |
| 105 |
continue; |
| 106 |
} |
| 107 |
if (len >= 4) { |
| 108 |
const unsigned char byte4 = data[3]; |
| 109 |
/* Is byte4 between 0x80 ~ 0xBF */ |
| 110 |
if (!TrailByteOk(byte4)) { |
| 111 |
return err_pos; |
| 112 |
} |
| 113 |
|
| 114 |
if (/* F0, 90..BF, 80..BF, 80..BF */ |
| 115 |
((byte1 == 0xF0 && byte2 >= 0x90) || |
| 116 |
/* F1..F3, 80..BF, 80..BF, 80..BF */ |
| 117 |
(byte1 >= 0xF1 && byte1 <= 0xF3) || |
| 118 |
/* F4, 80..8F, 80..BF, 80..BF */ |
| 119 |
(byte1 == 0xF4 && byte2 <= 0x8F))) { |
| 120 |
codepoint_bytes = 4; |
| 121 |
continue; |
| 122 |
} |
| 123 |
} |
| 124 |
} |
| 125 |
return err_pos; |
| 126 |
} |
| 127 |
if (ReturnPosition) { |
| 128 |
err_pos += codepoint_bytes; |
| 129 |
} |
| 130 |
/* if ReturnPosition is false, this returns 1. |
| 131 |
* if ReturnPosition is true, this returns err_pos. |
| 132 |
*/ |
| 133 |
return err_pos + (1 - ReturnPosition); |
| 134 |
} |
| 135 |
|
| 136 |
#ifdef __SSE4_1__ |
| 137 |
/* Returns the number of bytes needed to skip backwards to get to the first |
| 138 |
byte of codepoint. |
| 139 |
*/ |
| 140 |
inline int CodepointSkipBackwards(int32_t codepoint_word) { |
| 141 |
const int8_t* const codepoint = |
| 142 |
reinterpret_cast<const int8_t*>(&codepoint_word); |
| 143 |
if (!TrailByteOk(codepoint[3])) { |
| 144 |
return 1; |
| 145 |
} else if (!TrailByteOk(codepoint[2])) { |
| 146 |
return 2; |
| 147 |
} else if (!TrailByteOk(codepoint[1])) { |
| 148 |
return 3; |
| 149 |
} |
| 150 |
return 0; |
| 151 |
} |
| 152 |
#endif // __SSE4_1__ |
| 153 |
|
| 154 |
/* Skipping over ASCII as much as possible, per 8 bytes. It is intentional |
| 155 |
as most strings to check for validity consist only of 1 byte codepoints. |
| 156 |
*/ |
| 157 |
inline const char* SkipAscii(const char* data, const char* end) { |
| 158 |
while (8 <= end - data && |
| 159 |
(UNALIGNED_LOAD64(data) & 0x8080808080808080) == 0) { |
| 160 |
data += 8; |
| 161 |
} |
| 162 |
while (data < end && absl::ascii_isascii(*data)) { |
| 163 |
++data; |
| 164 |
} |
| 165 |
return data; |
| 166 |
} |
| 167 |
|
| 168 |
template <bool ReturnPosition> |
| 169 |
size_t ValidUTF8(const char* data, size_t len) { |
| 170 |
if (len == 0) return 1 - ReturnPosition; |
| 171 |
const char* const end = data + len; |
| 172 |
data = SkipAscii(data, end); |
| 173 |
/* SIMD algorithm always outperforms the naive version for any data of |
| 174 |
length >=16. |
| 175 |
*/ |
| 176 |
if (end - data < 16) { |
| 177 |
return (ReturnPosition ? (data - (end - len)) : 0) + |
| 178 |
ValidUTF8Span<ReturnPosition>(data, end); |
| 179 |
} |
| 180 |
#ifndef __SSE4_1__ |
| 181 |
return (ReturnPosition ? (data - (end - len)) : 0) + |
| 182 |
ValidUTF8Span<ReturnPosition>(data, end); |
| 183 |
#else |
| 184 |
/* This code checks that utf-8 ranges are structurally valid 16 bytes at once |
| 185 |
* using superscalar instructions. |
| 186 |
* The mapping between ranges of codepoint and their corresponding utf-8 |
| 187 |
* sequences is below. |
| 188 |
*/ |
| 189 |
|
| 190 |
/* |
| 191 |
* U+0000...U+007F 00...7F |
| 192 |
* U+0080...U+07FF C2...DF 80...BF |
| 193 |
* U+0800...U+0FFF E0 A0...BF 80...BF |
| 194 |
* U+1000...U+CFFF E1...EC 80...BF 80...BF |
| 195 |
* U+D000...U+D7FF ED 80...9F 80...BF |
| 196 |
* U+E000...U+FFFF EE...EF 80...BF 80...BF |
| 197 |
* U+10000...U+3FFFF F0 90...BF 80...BF 80...BF |
| 198 |
* U+40000...U+FFFFF F1...F3 80...BF 80...BF 80...BF |
| 199 |
* U+100000...U+10FFFF F4 80...8F 80...BF 80...BF |
| 200 |
*/ |
| 201 |
|
| 202 |
/* First we compute the type for each byte, as given by the table below. |
| 203 |
* This type will be used as an index later on. |
| 204 |
*/ |
| 205 |
|
| 206 |
/* |
| 207 |
* Index Min Max Byte Type |
| 208 |
* 0 00 7F Single byte sequence |
| 209 |
* 1,2,3 80 BF Second, third and fourth byte for many of the sequences. |
| 210 |
* 4 A0 BF Second byte after E0 |
| 211 |
* 5 80 9F Second byte after ED |
| 212 |
* 6 90 BF Second byte after F0 |
| 213 |
* 7 80 8F Second byte after F4 |
| 214 |
* 8 C2 F4 First non ASCII byte |
| 215 |
* 9..15 7F 80 Invalid byte |
| 216 |
*/ |
| 217 |
|
| 218 |
/* After the first step we compute the index for all bytes, then we permute |
| 219 |
the bytes according to their indices to check the ranges from the range |
| 220 |
table. |
| 221 |
* The range for a given type can be found in the range_min_table and |
| 222 |
range_max_table, the range for type/index X is in range_min_table[X] ... |
| 223 |
range_max_table[X]. |
| 224 |
*/ |
| 225 |
|
| 226 |
/* Algorithm: |
| 227 |
* Put index zero to all bytes. |
| 228 |
* Find all non ASCII characters, give them index 8. |
| 229 |
* For each tail byte in a codepoint sequence, give it an index corresponding |
| 230 |
to the 1 based index from the end. |
| 231 |
* If the first byte of the codepoint is in the [C0...DF] range, we write |
| 232 |
index 1 in the following byte. |
| 233 |
* If the first byte of the codepoint is in the range [E0...EF], we write |
| 234 |
indices 2 and 1 in the next two bytes. |
| 235 |
* If the first byte of the codepoint is in the range [F0...FF] we write |
| 236 |
indices 3,2,1 into the next three bytes. |
| 237 |
* For finding the number of bytes we need to look at high nibbles (4 bits) |
| 238 |
and do the lookup from the table, it can be done with shift by 4 + shuffle |
| 239 |
instructions. We call it `first_len`. |
| 240 |
* Then we shift first_len by 8 bits to get the indices of the 2nd bytes. |
| 241 |
* Saturating sub 1 and shift by 8 bits to get the indices of the 3rd bytes. |
| 242 |
* Again to get the indices of the 4th bytes. |
| 243 |
* Take OR of all that 4 values and check within range. |
| 244 |
*/ |
| 245 |
/* For example: |
| 246 |
* input C3 80 68 E2 80 20 A6 F0 A0 80 AC 20 F0 93 80 80 |
| 247 |
* first_len 1 0 0 2 0 0 0 3 0 0 0 0 3 0 0 0 |
| 248 |
* 1st byte 8 0 0 8 0 0 0 8 0 0 0 0 8 0 0 0 |
| 249 |
* 2nd byte 0 1 0 0 2 0 0 0 3 0 0 0 0 3 0 0 // Shift + sub |
| 250 |
* 3rd byte 0 0 0 0 0 1 0 0 0 2 0 0 0 0 2 0 // Shift + sub |
| 251 |
* 4th byte 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 // Shift + sub |
| 252 |
* Index 8 1 0 8 2 1 0 8 3 2 1 0 8 3 2 1 // OR of results |
| 253 |
*/ |
| 254 |
|
| 255 |
/* Checking for errors: |
| 256 |
* Error checking is done by looking up the high nibble (4 bits) of each byte |
| 257 |
against an error checking table. |
| 258 |
* Because the lookup value for the second byte depends of the value of the |
| 259 |
first byte in codepoint, we use saturated operations to adjust the index. |
| 260 |
* Specifically we need to add 2 for E0, 3 for ED, 3 for F0 and 4 for F4 to |
| 261 |
match the correct index. |
| 262 |
* If we subtract from all bytes EF then EO -> 241, ED -> 254, F0 -> 1, |
| 263 |
F4 -> 5 |
| 264 |
* Do saturating sub 240, then E0 -> 1, ED -> 14 and we can do lookup to |
| 265 |
match the adjustment |
| 266 |
* Add saturating 112, then F0 -> 113, F4 -> 117, all that were > 16 will |
| 267 |
be more 128 and lookup in ef_fe_table will return 0 but for F0 |
| 268 |
and F4 it will be 4 and 5 accordingly |
| 269 |
*/ |
| 270 |
/* |
| 271 |
* Then just check the appropriate ranges with greater/smaller equal |
| 272 |
instructions. Check tail with a naive algorithm. |
| 273 |
* To save from previous 16 byte checks we just align previous_first_len to |
| 274 |
get correct continuations of the codepoints. |
| 275 |
*/ |
| 276 |
|
| 277 |
/* |
| 278 |
* Map high nibble of "First Byte" to legal character length minus 1 |
| 279 |
* 0x00 ~ 0xBF --> 0 |
| 280 |
* 0xC0 ~ 0xDF --> 1 |
| 281 |
* 0xE0 ~ 0xEF --> 2 |
| 282 |
* 0xF0 ~ 0xFF --> 3 |
| 283 |
*/ |
| 284 |
const __m128i first_len_table = |
| 285 |
_mm_setr_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3); |
| 286 |
|
| 287 |
/* Map "First Byte" to 8-th item of range table (0xC2 ~ 0xF4) */ |
| 288 |
const __m128i first_range_table = |
| 289 |
_mm_setr_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8); |
| 290 |
|
| 291 |
/* |
| 292 |
* Range table, map range index to min and max values |
| 293 |
*/ |
| 294 |
const __m128i range_min_table = |
| 295 |
_mm_setr_epi8(0x00, 0x80, 0x80, 0x80, 0xA0, 0x80, 0x90, 0x80, 0xC2, 0x7F, |
| 296 |
0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F); |
| 297 |
|
| 298 |
const __m128i range_max_table = |
| 299 |
_mm_setr_epi8(0x7F, 0xBF, 0xBF, 0xBF, 0xBF, 0x9F, 0xBF, 0x8F, 0xF4, 0x80, |
| 300 |
0x80, 0x80, 0x80, 0x80, 0x80, 0x80); |
| 301 |
|
| 302 |
/* |
| 303 |
* Tables for fast handling of four special First Bytes(E0,ED,F0,F4), after |
| 304 |
* which the Second Byte are not 80~BF. It contains "range index adjustment". |
| 305 |
* +------------+---------------+------------------+----------------+ |
| 306 |
* | First Byte | original range| range adjustment | adjusted range | |
| 307 |
* +------------+---------------+------------------+----------------+ |
| 308 |
* | E0 | 2 | 2 | 4 | |
| 309 |
* +------------+---------------+------------------+----------------+ |
| 310 |
* | ED | 2 | 3 | 5 | |
| 311 |
* +------------+---------------+------------------+----------------+ |
| 312 |
* | F0 | 3 | 3 | 6 | |
| 313 |
* +------------+---------------+------------------+----------------+ |
| 314 |
* | F4 | 4 | 4 | 8 | |
| 315 |
* +------------+---------------+------------------+----------------+ |
| 316 |
*/ |
| 317 |
|
| 318 |
/* df_ee_table[1] -> E0, df_ee_table[14] -> ED as ED - E0 = 13 */ |
| 319 |
// The values represent the adjustment in the Range Index table for a correct |
| 320 |
// index. |
| 321 |
const __m128i df_ee_table = |
| 322 |
_mm_setr_epi8(0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0); |
| 323 |
|
| 324 |
/* ef_fe_table[1] -> F0, ef_fe_table[5] -> F4, F4 - F0 = 4 */ |
| 325 |
// The values represent the adjustment in the Range Index table for a correct |
| 326 |
// index. |
| 327 |
const __m128i ef_fe_table = |
| 328 |
_mm_setr_epi8(0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); |
| 329 |
|
| 330 |
__m128i prev_input = _mm_set1_epi8(0); |
| 331 |
__m128i prev_first_len = _mm_set1_epi8(0); |
| 332 |
__m128i error = _mm_set1_epi8(0); |
| 333 |
while (end - data >= 16) { |
| 334 |
const __m128i input = |
| 335 |
_mm_loadu_si128(reinterpret_cast<const __m128i*>(data)); |
| 336 |
|
| 337 |
/* high_nibbles = input >> 4 */ |
| 338 |
const __m128i high_nibbles = |
| 339 |
_mm_and_si128(_mm_srli_epi16(input, 4), _mm_set1_epi8(0x0F)); |
| 340 |
|
| 341 |
/* first_len = legal character length minus 1 */ |
| 342 |
/* 0 for 00~7F, 1 for C0~DF, 2 for E0~EF, 3 for F0~FF */ |
| 343 |
/* first_len = first_len_table[high_nibbles] */ |
| 344 |
__m128i first_len = _mm_shuffle_epi8(first_len_table, high_nibbles); |
| 345 |
|
| 346 |
/* First Byte: set range index to 8 for bytes within 0xC0 ~ 0xFF */ |
| 347 |
/* range = first_range_table[high_nibbles] */ |
| 348 |
__m128i range = _mm_shuffle_epi8(first_range_table, high_nibbles); |
| 349 |
|
| 350 |
/* Second Byte: set range index to first_len */ |
| 351 |
/* 0 for 00~7F, 1 for C0~DF, 2 for E0~EF, 3 for F0~FF */ |
| 352 |
/* range |= (first_len, prev_first_len) << 1 byte */ |
| 353 |
range = _mm_or_si128(range, _mm_alignr_epi8(first_len, prev_first_len, 15)); |
| 354 |
|
| 355 |
/* Third Byte: set range index to saturate_sub(first_len, 1) */ |
| 356 |
/* 0 for 00~7F, 0 for C0~DF, 1 for E0~EF, 2 for F0~FF */ |
| 357 |
__m128i tmp1; |
| 358 |
__m128i tmp2; |
| 359 |
/* tmp1 = saturate_sub(first_len, 1) */ |
| 360 |
tmp1 = _mm_subs_epu8(first_len, _mm_set1_epi8(1)); |
| 361 |
/* tmp2 = saturate_sub(prev_first_len, 1) */ |
| 362 |
tmp2 = _mm_subs_epu8(prev_first_len, _mm_set1_epi8(1)); |
| 363 |
/* range |= (tmp1, tmp2) << 2 bytes */ |
| 364 |
range = _mm_or_si128(range, _mm_alignr_epi8(tmp1, tmp2, 14)); |
| 365 |
|
| 366 |
/* Fourth Byte: set range index to saturate_sub(first_len, 2) */ |
| 367 |
/* 0 for 00~7F, 0 for C0~DF, 0 for E0~EF, 1 for F0~FF */ |
| 368 |
/* tmp1 = saturate_sub(first_len, 2) */ |
| 369 |
tmp1 = _mm_subs_epu8(first_len, _mm_set1_epi8(2)); |
| 370 |
/* tmp2 = saturate_sub(prev_first_len, 2) */ |
| 371 |
tmp2 = _mm_subs_epu8(prev_first_len, _mm_set1_epi8(2)); |
| 372 |
/* range |= (tmp1, tmp2) << 3 bytes */ |
| 373 |
range = _mm_or_si128(range, _mm_alignr_epi8(tmp1, tmp2, 13)); |
| 374 |
|
| 375 |
/* |
| 376 |
* Now we have below range indices calculated |
| 377 |
* Correct cases: |
| 378 |
* - 8 for C0~FF |
| 379 |
* - 3 for 1st byte after F0~FF |
| 380 |
* - 2 for 1st byte after E0~EF or 2nd byte after F0~FF |
| 381 |
* - 1 for 1st byte after C0~DF or 2nd byte after E0~EF or |
| 382 |
* 3rd byte after F0~FF |
| 383 |
* - 0 for others |
| 384 |
* Error cases: |
| 385 |
* >9 for non ascii First Byte overlapping |
| 386 |
* E.g., F1 80 C2 90 --> 8 3 10 2, where 10 indicates error |
| 387 |
*/ |
| 388 |
|
| 389 |
/* Adjust Second Byte range for special First Bytes(E0,ED,F0,F4) */ |
| 390 |
/* Overlaps lead to index 9~15, which are illegal in range table */ |
| 391 |
__m128i shift1; |
| 392 |
__m128i pos; |
| 393 |
__m128i range2; |
| 394 |
/* shift1 = (input, prev_input) << 1 byte */ |
| 395 |
shift1 = _mm_alignr_epi8(input, prev_input, 15); |
| 396 |
pos = _mm_sub_epi8(shift1, _mm_set1_epi8(0xEF)); |
| 397 |
/* |
| 398 |
* shift1: | EF F0 ... FE | FF 00 ... ... DE | DF E0 ... EE | |
| 399 |
* pos: | 0 1 15 | 16 17 239| 240 241 255| |
| 400 |
* pos-240: | 0 0 0 | 0 0 0 | 0 1 15 | |
| 401 |
* pos+112: | 112 113 127| >= 128 | >= 128 | |
| 402 |
*/ |
| 403 |
tmp1 = _mm_subs_epu8(pos, _mm_set1_epi8(-16)); |
| 404 |
range2 = _mm_shuffle_epi8(df_ee_table, tmp1); |
| 405 |
tmp2 = _mm_adds_epu8(pos, _mm_set1_epi8(112)); |
| 406 |
range2 = _mm_add_epi8(range2, _mm_shuffle_epi8(ef_fe_table, tmp2)); |
| 407 |
|
| 408 |
range = _mm_add_epi8(range, range2); |
| 409 |
|
| 410 |
/* Load min and max values per calculated range index */ |
| 411 |
__m128i min_range = _mm_shuffle_epi8(range_min_table, range); |
| 412 |
__m128i max_range = _mm_shuffle_epi8(range_max_table, range); |
| 413 |
|
| 414 |
/* Check value range */ |
| 415 |
if (ReturnPosition) { |
| 416 |
error = _mm_cmplt_epi8(input, min_range); |
| 417 |
error = _mm_or_si128(error, _mm_cmpgt_epi8(input, max_range)); |
| 418 |
/* 5% performance drop from this conditional branch */ |
| 419 |
if (!_mm_testz_si128(error, error)) { |
| 420 |
break; |
| 421 |
} |
| 422 |
} else { |
| 423 |
error = _mm_or_si128(error, _mm_cmplt_epi8(input, min_range)); |
| 424 |
error = _mm_or_si128(error, _mm_cmpgt_epi8(input, max_range)); |
| 425 |
} |
| 426 |
|
| 427 |
prev_input = input; |
| 428 |
prev_first_len = first_len; |
| 429 |
|
| 430 |
data += 16; |
| 431 |
} |
| 432 |
/* If we got to the end, we don't need to skip any bytes backwards */ |
| 433 |
if (ReturnPosition && (data - (end - len)) == 0) { |
| 434 |
return ValidUTF8Span<true>(data, end); |
| 435 |
} |
| 436 |
/* Find previous codepoint (not 80~BF) */ |
| 437 |
data -= CodepointSkipBackwards(_mm_extract_epi32(prev_input, 3)); |
| 438 |
if (ReturnPosition) { |
| 439 |
return (data - (end - len)) + ValidUTF8Span<true>(data, end); |
| 440 |
} |
| 441 |
/* Test if there was any error */ |
| 442 |
if (!_mm_testz_si128(error, error)) { |
| 443 |
return 0; |
| 444 |
} |
| 445 |
/* Check the tail */ |
| 446 |
return ValidUTF8Span<false>(data, end); |
| 447 |
#endif |
| 448 |
} |
| 449 |
|
| 450 |
} // namespace |
| 451 |
|
| 452 |
bool IsStructurallyValid(absl::string_view str) { |
| 453 |
return ValidUTF8</*ReturnPosition=*/false>(str.data(), str.size()); |
| 454 |
} |
| 455 |
|
| 456 |
size_t SpanStructurallyValid(absl::string_view str) { |
| 457 |
return ValidUTF8</*ReturnPosition=*/true>(str.data(), str.size()); |
| 458 |
} |
| 459 |
|
| 460 |
} // namespace utf8_range |