Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 1 | /************************************************* |
| 2 | * Perl-Compatible Regular Expressions * |
| 3 | *************************************************/ |
| 4 | |
| 5 | /* PCRE is a library of functions to support regular expressions whose syntax |
| 6 | and semantics are as close as possible to those of the Perl 5 language. |
| 7 | |
| 8 | Written by Philip Hazel |
| 9 | This module by Zoltan Herczeg and Sebastian Pop |
| 10 | Original API code Copyright (c) 1997-2012 University of Cambridge |
| 11 | New API code Copyright (c) 2016-2019 University of Cambridge |
| 12 | |
| 13 | ----------------------------------------------------------------------------- |
| 14 | Redistribution and use in source and binary forms, with or without |
| 15 | modification, are permitted provided that the following conditions are met: |
| 16 | |
| 17 | * Redistributions of source code must retain the above copyright notice, |
| 18 | this list of conditions and the following disclaimer. |
| 19 | |
| 20 | * Redistributions in binary form must reproduce the above copyright |
| 21 | notice, this list of conditions and the following disclaimer in the |
| 22 | documentation and/or other materials provided with the distribution. |
| 23 | |
| 24 | * Neither the name of the University of Cambridge nor the names of its |
| 25 | contributors may be used to endorse or promote products derived from |
| 26 | this software without specific prior written permission. |
| 27 | |
| 28 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| 29 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 30 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 31 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| 32 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 33 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 34 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 35 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| 36 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 37 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 38 | POSSIBILITY OF SUCH DAMAGE. |
| 39 | ----------------------------------------------------------------------------- |
| 40 | */ |
| 41 | |
| 42 | # if defined(FFCS) |
| 43 | # if defined(FF_UTF) |
| 44 | # define FF_FUN ffcs_utf |
| 45 | # else |
| 46 | # define FF_FUN ffcs |
| 47 | # endif |
| 48 | |
| 49 | # elif defined(FFCS_2) |
| 50 | # if defined(FF_UTF) |
| 51 | # define FF_FUN ffcs_2_utf |
| 52 | # else |
| 53 | # define FF_FUN ffcs_2 |
| 54 | # endif |
| 55 | |
| 56 | # elif defined(FFCS_MASK) |
| 57 | # if defined(FF_UTF) |
| 58 | # define FF_FUN ffcs_mask_utf |
| 59 | # else |
| 60 | # define FF_FUN ffcs_mask |
| 61 | # endif |
| 62 | |
| 63 | # elif defined(FFCPS_0) |
| 64 | # if defined (FF_UTF) |
| 65 | # define FF_FUN ffcps_0_utf |
| 66 | # else |
| 67 | # define FF_FUN ffcps_0 |
| 68 | # endif |
| 69 | |
| 70 | # elif defined (FFCPS_1) |
| 71 | # if defined (FF_UTF) |
| 72 | # define FF_FUN ffcps_1_utf |
| 73 | # else |
| 74 | # define FF_FUN ffcps_1 |
| 75 | # endif |
| 76 | |
| 77 | # elif defined (FFCPS_DEFAULT) |
| 78 | # if defined (FF_UTF) |
| 79 | # define FF_FUN ffcps_default_utf |
| 80 | # else |
| 81 | # define FF_FUN ffcps_default |
| 82 | # endif |
| 83 | # endif |
| 84 | |
| 85 | static sljit_u8* SLJIT_FUNC FF_FUN(sljit_u8 *str_end, sljit_u8 *str_ptr, sljit_uw offs1, sljit_uw offs2, sljit_uw chars) |
| 86 | #undef FF_FUN |
| 87 | { |
| 88 | quad_word qw; |
| 89 | int_char ic; |
Elliott Hughes | 3435c42 | 2020-12-04 13:18:28 -0800 | [diff] [blame] | 90 | |
| 91 | SLJIT_UNUSED_ARG(offs1); |
| 92 | SLJIT_UNUSED_ARG(offs2); |
| 93 | |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 94 | ic.x = chars; |
| 95 | |
| 96 | #if defined(FFCS) |
| 97 | sljit_u8 c1 = ic.c.c1; |
| 98 | vect_t vc1 = VDUPQ(c1); |
| 99 | |
| 100 | #elif defined(FFCS_2) |
| 101 | sljit_u8 c1 = ic.c.c1; |
| 102 | vect_t vc1 = VDUPQ(c1); |
| 103 | sljit_u8 c2 = ic.c.c2; |
| 104 | vect_t vc2 = VDUPQ(c2); |
| 105 | |
| 106 | #elif defined(FFCS_MASK) |
| 107 | sljit_u8 c1 = ic.c.c1; |
| 108 | vect_t vc1 = VDUPQ(c1); |
| 109 | sljit_u8 mask = ic.c.c2; |
| 110 | vect_t vmask = VDUPQ(mask); |
| 111 | #endif |
| 112 | |
| 113 | #if defined(FFCPS) |
| 114 | compare_type compare1_type = compare_match1; |
| 115 | compare_type compare2_type = compare_match1; |
| 116 | vect_t cmp1a, cmp1b, cmp2a, cmp2b; |
| 117 | const sljit_u32 diff = IN_UCHARS(offs1 - offs2); |
| 118 | PCRE2_UCHAR char1a = ic.c.c1; |
| 119 | PCRE2_UCHAR char2a = ic.c.c3; |
| 120 | |
| 121 | # ifdef FFCPS_CHAR1A2A |
| 122 | cmp1a = VDUPQ(char1a); |
| 123 | cmp2a = VDUPQ(char2a); |
| 124 | cmp1b = VDUPQ(0); /* to avoid errors on older compilers -Werror=maybe-uninitialized */ |
| 125 | cmp2b = VDUPQ(0); /* to avoid errors on older compilers -Werror=maybe-uninitialized */ |
| 126 | # else |
| 127 | PCRE2_UCHAR char1b = ic.c.c2; |
| 128 | PCRE2_UCHAR char2b = ic.c.c4; |
| 129 | if (char1a == char1b) |
| 130 | { |
| 131 | cmp1a = VDUPQ(char1a); |
| 132 | cmp1b = VDUPQ(0); /* to avoid errors on older compilers -Werror=maybe-uninitialized */ |
| 133 | } |
| 134 | else |
| 135 | { |
| 136 | sljit_u32 bit1 = char1a ^ char1b; |
| 137 | if (is_powerof2(bit1)) |
| 138 | { |
| 139 | compare1_type = compare_match1i; |
| 140 | cmp1a = VDUPQ(char1a | bit1); |
| 141 | cmp1b = VDUPQ(bit1); |
| 142 | } |
| 143 | else |
| 144 | { |
| 145 | compare1_type = compare_match2; |
| 146 | cmp1a = VDUPQ(char1a); |
| 147 | cmp1b = VDUPQ(char1b); |
| 148 | } |
| 149 | } |
| 150 | |
| 151 | if (char2a == char2b) |
| 152 | { |
| 153 | cmp2a = VDUPQ(char2a); |
| 154 | cmp2b = VDUPQ(0); /* to avoid errors on older compilers -Werror=maybe-uninitialized */ |
| 155 | } |
| 156 | else |
| 157 | { |
| 158 | sljit_u32 bit2 = char2a ^ char2b; |
| 159 | if (is_powerof2(bit2)) |
| 160 | { |
| 161 | compare2_type = compare_match1i; |
| 162 | cmp2a = VDUPQ(char2a | bit2); |
| 163 | cmp2b = VDUPQ(bit2); |
| 164 | } |
| 165 | else |
| 166 | { |
| 167 | compare2_type = compare_match2; |
| 168 | cmp2a = VDUPQ(char2a); |
| 169 | cmp2b = VDUPQ(char2b); |
| 170 | } |
| 171 | } |
| 172 | # endif |
| 173 | |
| 174 | str_ptr += IN_UCHARS(offs1); |
| 175 | #endif |
| 176 | |
| 177 | #if PCRE2_CODE_UNIT_WIDTH != 8 |
| 178 | vect_t char_mask = VDUPQ(0xff); |
| 179 | #endif |
| 180 | |
| 181 | #if defined(FF_UTF) |
| 182 | restart:; |
| 183 | #endif |
| 184 | |
| 185 | #if defined(FFCPS) |
| 186 | sljit_u8 *p1 = str_ptr - diff; |
| 187 | #endif |
| 188 | sljit_s32 align_offset = ((uint64_t)str_ptr & 0xf); |
| 189 | str_ptr = (sljit_u8 *) ((uint64_t)str_ptr & ~0xf); |
| 190 | vect_t data = VLD1Q(str_ptr); |
| 191 | #if PCRE2_CODE_UNIT_WIDTH != 8 |
| 192 | data = VANDQ(data, char_mask); |
| 193 | #endif |
| 194 | |
| 195 | #if defined(FFCS) |
| 196 | vect_t eq = VCEQQ(data, vc1); |
| 197 | |
| 198 | #elif defined(FFCS_2) |
| 199 | vect_t eq1 = VCEQQ(data, vc1); |
| 200 | vect_t eq2 = VCEQQ(data, vc2); |
| 201 | vect_t eq = VORRQ(eq1, eq2); |
| 202 | |
| 203 | #elif defined(FFCS_MASK) |
| 204 | vect_t eq = VORRQ(data, vmask); |
| 205 | eq = VCEQQ(eq, vc1); |
| 206 | |
| 207 | #elif defined(FFCPS) |
| 208 | # if defined(FFCPS_DIFF1) |
| 209 | vect_t prev_data = data; |
| 210 | # endif |
| 211 | |
| 212 | vect_t data2; |
| 213 | if (p1 < str_ptr) |
| 214 | { |
| 215 | data2 = VLD1Q(str_ptr - diff); |
| 216 | #if PCRE2_CODE_UNIT_WIDTH != 8 |
| 217 | data2 = VANDQ(data2, char_mask); |
| 218 | #endif |
| 219 | } |
| 220 | else |
| 221 | data2 = shift_left_n_lanes(data, offs1 - offs2); |
| 222 | |
| 223 | if (compare1_type == compare_match1) |
| 224 | data = VCEQQ(data, cmp1a); |
| 225 | else |
| 226 | data = fast_forward_char_pair_compare(compare1_type, data, cmp1a, cmp1b); |
| 227 | |
| 228 | if (compare2_type == compare_match1) |
| 229 | data2 = VCEQQ(data2, cmp2a); |
| 230 | else |
| 231 | data2 = fast_forward_char_pair_compare(compare2_type, data2, cmp2a, cmp2b); |
| 232 | |
| 233 | vect_t eq = VANDQ(data, data2); |
| 234 | #endif |
| 235 | |
| 236 | VST1Q(qw.mem, eq); |
| 237 | /* Ignore matches before the first STR_PTR. */ |
| 238 | if (align_offset < 8) |
| 239 | { |
| 240 | qw.dw[0] >>= align_offset * 8; |
| 241 | if (qw.dw[0]) |
| 242 | { |
| 243 | str_ptr += align_offset + __builtin_ctzll(qw.dw[0]) / 8; |
| 244 | goto match; |
| 245 | } |
| 246 | if (qw.dw[1]) |
| 247 | { |
| 248 | str_ptr += 8 + __builtin_ctzll(qw.dw[1]) / 8; |
| 249 | goto match; |
| 250 | } |
| 251 | } |
| 252 | else |
| 253 | { |
| 254 | qw.dw[1] >>= (align_offset - 8) * 8; |
| 255 | if (qw.dw[1]) |
| 256 | { |
| 257 | str_ptr += align_offset + __builtin_ctzll(qw.dw[1]) / 8; |
| 258 | goto match; |
| 259 | } |
| 260 | } |
| 261 | str_ptr += 16; |
| 262 | |
| 263 | while (str_ptr < str_end) |
| 264 | { |
| 265 | vect_t orig_data = VLD1Q(str_ptr); |
| 266 | #if PCRE2_CODE_UNIT_WIDTH != 8 |
| 267 | orig_data = VANDQ(orig_data, char_mask); |
| 268 | #endif |
| 269 | data = orig_data; |
| 270 | |
| 271 | #if defined(FFCS) |
| 272 | eq = VCEQQ(data, vc1); |
| 273 | |
| 274 | #elif defined(FFCS_2) |
| 275 | eq1 = VCEQQ(data, vc1); |
| 276 | eq2 = VCEQQ(data, vc2); |
| 277 | eq = VORRQ(eq1, eq2); |
| 278 | |
| 279 | #elif defined(FFCS_MASK) |
| 280 | eq = VORRQ(data, vmask); |
| 281 | eq = VCEQQ(eq, vc1); |
| 282 | #endif |
| 283 | |
| 284 | #if defined(FFCPS) |
| 285 | # if defined (FFCPS_DIFF1) |
| 286 | data2 = VEXTQ(prev_data, data, VECTOR_FACTOR - 1); |
| 287 | # else |
| 288 | data2 = VLD1Q(str_ptr - diff); |
| 289 | # if PCRE2_CODE_UNIT_WIDTH != 8 |
| 290 | data2 = VANDQ(data2, char_mask); |
| 291 | # endif |
| 292 | # endif |
| 293 | |
| 294 | # ifdef FFCPS_CHAR1A2A |
| 295 | data = VCEQQ(data, cmp1a); |
| 296 | data2 = VCEQQ(data2, cmp2a); |
| 297 | # else |
| 298 | if (compare1_type == compare_match1) |
| 299 | data = VCEQQ(data, cmp1a); |
| 300 | else |
| 301 | data = fast_forward_char_pair_compare(compare1_type, data, cmp1a, cmp1b); |
| 302 | if (compare2_type == compare_match1) |
| 303 | data2 = VCEQQ(data2, cmp2a); |
| 304 | else |
| 305 | data2 = fast_forward_char_pair_compare(compare2_type, data2, cmp2a, cmp2b); |
| 306 | # endif |
| 307 | |
| 308 | eq = VANDQ(data, data2); |
| 309 | #endif |
| 310 | |
| 311 | VST1Q(qw.mem, eq); |
| 312 | if (qw.dw[0]) |
| 313 | str_ptr += __builtin_ctzll(qw.dw[0]) / 8; |
| 314 | else if (qw.dw[1]) |
| 315 | str_ptr += 8 + __builtin_ctzll(qw.dw[1]) / 8; |
| 316 | else { |
| 317 | str_ptr += 16; |
| 318 | #if defined (FFCPS_DIFF1) |
| 319 | prev_data = orig_data; |
| 320 | #endif |
| 321 | continue; |
| 322 | } |
| 323 | |
| 324 | match:; |
| 325 | if (str_ptr >= str_end) |
| 326 | /* Failed match. */ |
| 327 | return NULL; |
| 328 | |
| 329 | #if defined(FF_UTF) |
| 330 | if (utf_continue(str_ptr + IN_UCHARS(-offs1))) |
| 331 | { |
| 332 | /* Not a match. */ |
| 333 | str_ptr += IN_UCHARS(1); |
| 334 | goto restart; |
| 335 | } |
| 336 | #endif |
| 337 | |
| 338 | /* Match. */ |
| 339 | #if defined (FFCPS) |
| 340 | str_ptr -= IN_UCHARS(offs1); |
| 341 | #endif |
| 342 | return str_ptr; |
| 343 | } |
| 344 | |
| 345 | /* Failed match. */ |
| 346 | return NULL; |
| 347 | } |