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 Original API code Copyright (c) 1997-2012 University of Cambridge 10 New API code Copyright (c) 2016 University of Cambridge 11 12 ----------------------------------------------------------------------------- 13 Redistribution and use in source and binary forms, with or without 14 modification, are permitted provided that the following conditions are met: 15 16 * Redistributions of source code must retain the above copyright notice, 17 this list of conditions and the following disclaimer. 18 19 * Redistributions in binary form must reproduce the above copyright 20 notice, this list of conditions and the following disclaimer in the 21 documentation and/or other materials provided with the distribution. 22 23 * Neither the name of the University of Cambridge nor the names of its 24 contributors may be used to endorse or promote products derived from 25 this software without specific prior written permission. 26 27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 POSSIBILITY OF SUCH DAMAGE. 38 ----------------------------------------------------------------------------- 39 */ 40 41 #ifdef HAVE_CONFIG_H 42 #include "config.h" 43 #endif 44 45 #include "pcre2_internal.h" 46 47 #ifdef SUPPORT_JIT 48 49 /* All-in-one: Since we use the JIT compiler only from here, 50 we just include it. This way we don't need to touch the build 51 system files. */ 52 53 #define SLJIT_CONFIG_AUTO 1 54 #define SLJIT_CONFIG_STATIC 1 55 #define SLJIT_VERBOSE 0 56 57 #ifdef PCRE2_DEBUG 58 #define SLJIT_DEBUG 1 59 #else 60 #define SLJIT_DEBUG 0 61 #endif 62 63 #define SLJIT_MALLOC(size, allocator_data) pcre2_jit_malloc(size, allocator_data) 64 #define SLJIT_FREE(ptr, allocator_data) pcre2_jit_free(ptr, allocator_data) 65 66 static void * pcre2_jit_malloc(size_t size, void *allocator_data) 67 { 68 pcre2_memctl *allocator = ((pcre2_memctl*)allocator_data); 69 return allocator->malloc(size, allocator->memory_data); 70 } 71 72 static void pcre2_jit_free(void *ptr, void *allocator_data) 73 { 74 pcre2_memctl *allocator = ((pcre2_memctl*)allocator_data); 75 allocator->free(ptr, allocator->memory_data); 76 } 77 78 #include "sljit/sljitLir.c" 79 80 #if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED 81 #error Unsupported architecture 82 #endif 83 84 /* Defines for debugging purposes. */ 85 86 /* 1 - Use unoptimized capturing brackets. 87 2 - Enable capture_last_ptr (includes option 1). */ 88 /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */ 89 90 /* 1 - Always have a control head. */ 91 /* #define DEBUG_FORCE_CONTROL_HEAD 1 */ 92 93 /* Allocate memory for the regex stack on the real machine stack. 94 Fast, but limited size. */ 95 #define MACHINE_STACK_SIZE 32768 96 97 /* Growth rate for stack allocated by the OS. Should be the multiply 98 of page size. */ 99 #define STACK_GROWTH_RATE 8192 100 101 /* Enable to check that the allocation could destroy temporaries. */ 102 #if defined SLJIT_DEBUG && SLJIT_DEBUG 103 #define DESTROY_REGISTERS 1 104 #endif 105 106 /* 107 Short summary about the backtracking mechanism empolyed by the jit code generator: 108 109 The code generator follows the recursive nature of the PERL compatible regular 110 expressions. The basic blocks of regular expressions are condition checkers 111 whose execute different commands depending on the result of the condition check. 112 The relationship between the operators can be horizontal (concatenation) and 113 vertical (sub-expression) (See struct backtrack_common for more details). 114 115 'ab' - 'a' and 'b' regexps are concatenated 116 'a+' - 'a' is the sub-expression of the '+' operator 117 118 The condition checkers are boolean (true/false) checkers. Machine code is generated 119 for the checker itself and for the actions depending on the result of the checker. 120 The 'true' case is called as the matching path (expected path), and the other is called as 121 the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken 122 branches on the matching path. 123 124 Greedy star operator (*) : 125 Matching path: match happens. 126 Backtrack path: match failed. 127 Non-greedy star operator (*?) : 128 Matching path: no need to perform a match. 129 Backtrack path: match is required. 130 131 The following example shows how the code generated for a capturing bracket 132 with two alternatives. Let A, B, C, D are arbirary regular expressions, and 133 we have the following regular expression: 134 135 A(B|C)D 136 137 The generated code will be the following: 138 139 A matching path 140 '(' matching path (pushing arguments to the stack) 141 B matching path 142 ')' matching path (pushing arguments to the stack) 143 D matching path 144 return with successful match 145 146 D backtrack path 147 ')' backtrack path (If we arrived from "C" jump to the backtrack of "C") 148 B backtrack path 149 C expected path 150 jump to D matching path 151 C backtrack path 152 A backtrack path 153 154 Notice, that the order of backtrack code paths are the opposite of the fast 155 code paths. In this way the topmost value on the stack is always belong 156 to the current backtrack code path. The backtrack path must check 157 whether there is a next alternative. If so, it needs to jump back to 158 the matching path eventually. Otherwise it needs to clear out its own stack 159 frame and continue the execution on the backtrack code paths. 160 */ 161 162 /* 163 Saved stack frames: 164 165 Atomic blocks and asserts require reloading the values of private data 166 when the backtrack mechanism performed. Because of OP_RECURSE, the data 167 are not necessarly known in compile time, thus we need a dynamic restore 168 mechanism. 169 170 The stack frames are stored in a chain list, and have the following format: 171 ([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ] 172 173 Thus we can restore the private data to a particular point in the stack. 174 */ 175 176 typedef struct jit_arguments { 177 /* Pointers first. */ 178 struct sljit_stack *stack; 179 PCRE2_SPTR str; 180 PCRE2_SPTR begin; 181 PCRE2_SPTR end; 182 pcre2_match_data *match_data; 183 PCRE2_SPTR startchar_ptr; 184 PCRE2_UCHAR *mark_ptr; 185 int (*callout)(pcre2_callout_block *, void *); 186 void *callout_data; 187 /* Everything else after. */ 188 sljit_uw offset_limit; 189 sljit_u32 limit_match; 190 sljit_u32 oveccount; 191 sljit_u32 options; 192 } jit_arguments; 193 194 #define JIT_NUMBER_OF_COMPILE_MODES 3 195 196 typedef struct executable_functions { 197 void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES]; 198 void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES]; 199 sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES]; 200 sljit_u32 top_bracket; 201 sljit_u32 limit_match; 202 } executable_functions; 203 204 typedef struct jump_list { 205 struct sljit_jump *jump; 206 struct jump_list *next; 207 } jump_list; 208 209 typedef struct stub_list { 210 struct sljit_jump *start; 211 struct sljit_label *quit; 212 struct stub_list *next; 213 } stub_list; 214 215 typedef struct label_addr_list { 216 struct sljit_label *label; 217 sljit_uw *update_addr; 218 struct label_addr_list *next; 219 } label_addr_list; 220 221 enum frame_types { 222 no_frame = -1, 223 no_stack = -2 224 }; 225 226 enum control_types { 227 type_mark = 0, 228 type_then_trap = 1 229 }; 230 231 typedef int (SLJIT_CALL *jit_function)(jit_arguments *args); 232 233 /* The following structure is the key data type for the recursive 234 code generator. It is allocated by compile_matchingpath, and contains 235 the arguments for compile_backtrackingpath. Must be the first member 236 of its descendants. */ 237 typedef struct backtrack_common { 238 /* Concatenation stack. */ 239 struct backtrack_common *prev; 240 jump_list *nextbacktracks; 241 /* Internal stack (for component operators). */ 242 struct backtrack_common *top; 243 jump_list *topbacktracks; 244 /* Opcode pointer. */ 245 PCRE2_SPTR cc; 246 } backtrack_common; 247 248 typedef struct assert_backtrack { 249 backtrack_common common; 250 jump_list *condfailed; 251 /* Less than 0 if a frame is not needed. */ 252 int framesize; 253 /* Points to our private memory word on the stack. */ 254 int private_data_ptr; 255 /* For iterators. */ 256 struct sljit_label *matchingpath; 257 } assert_backtrack; 258 259 typedef struct bracket_backtrack { 260 backtrack_common common; 261 /* Where to coninue if an alternative is successfully matched. */ 262 struct sljit_label *alternative_matchingpath; 263 /* For rmin and rmax iterators. */ 264 struct sljit_label *recursive_matchingpath; 265 /* For greedy ? operator. */ 266 struct sljit_label *zero_matchingpath; 267 /* Contains the branches of a failed condition. */ 268 union { 269 /* Both for OP_COND, OP_SCOND. */ 270 jump_list *condfailed; 271 assert_backtrack *assert; 272 /* For OP_ONCE. Less than 0 if not needed. */ 273 int framesize; 274 } u; 275 /* Points to our private memory word on the stack. */ 276 int private_data_ptr; 277 } bracket_backtrack; 278 279 typedef struct bracketpos_backtrack { 280 backtrack_common common; 281 /* Points to our private memory word on the stack. */ 282 int private_data_ptr; 283 /* Reverting stack is needed. */ 284 int framesize; 285 /* Allocated stack size. */ 286 int stacksize; 287 } bracketpos_backtrack; 288 289 typedef struct braminzero_backtrack { 290 backtrack_common common; 291 struct sljit_label *matchingpath; 292 } braminzero_backtrack; 293 294 typedef struct char_iterator_backtrack { 295 backtrack_common common; 296 /* Next iteration. */ 297 struct sljit_label *matchingpath; 298 union { 299 jump_list *backtracks; 300 struct { 301 unsigned int othercasebit; 302 PCRE2_UCHAR chr; 303 BOOL enabled; 304 } charpos; 305 } u; 306 } char_iterator_backtrack; 307 308 typedef struct ref_iterator_backtrack { 309 backtrack_common common; 310 /* Next iteration. */ 311 struct sljit_label *matchingpath; 312 } ref_iterator_backtrack; 313 314 typedef struct recurse_entry { 315 struct recurse_entry *next; 316 /* Contains the function entry. */ 317 struct sljit_label *entry; 318 /* Collects the calls until the function is not created. */ 319 jump_list *calls; 320 /* Points to the starting opcode. */ 321 sljit_sw start; 322 } recurse_entry; 323 324 typedef struct recurse_backtrack { 325 backtrack_common common; 326 BOOL inlined_pattern; 327 } recurse_backtrack; 328 329 #define OP_THEN_TRAP OP_TABLE_LENGTH 330 331 typedef struct then_trap_backtrack { 332 backtrack_common common; 333 /* If then_trap is not NULL, this structure contains the real 334 then_trap for the backtracking path. */ 335 struct then_trap_backtrack *then_trap; 336 /* Points to the starting opcode. */ 337 sljit_sw start; 338 /* Exit point for the then opcodes of this alternative. */ 339 jump_list *quit; 340 /* Frame size of the current alternative. */ 341 int framesize; 342 } then_trap_backtrack; 343 344 #define MAX_RANGE_SIZE 4 345 346 typedef struct compiler_common { 347 /* The sljit ceneric compiler. */ 348 struct sljit_compiler *compiler; 349 /* First byte code. */ 350 PCRE2_SPTR start; 351 /* Maps private data offset to each opcode. */ 352 sljit_s32 *private_data_ptrs; 353 /* Chain list of read-only data ptrs. */ 354 void *read_only_data_head; 355 /* Tells whether the capturing bracket is optimized. */ 356 sljit_u8 *optimized_cbracket; 357 /* Tells whether the starting offset is a target of then. */ 358 sljit_u8 *then_offsets; 359 /* Current position where a THEN must jump. */ 360 then_trap_backtrack *then_trap; 361 /* Starting offset of private data for capturing brackets. */ 362 sljit_s32 cbra_ptr; 363 /* Output vector starting point. Must be divisible by 2. */ 364 sljit_s32 ovector_start; 365 /* Points to the starting character of the current match. */ 366 sljit_s32 start_ptr; 367 /* Last known position of the requested byte. */ 368 sljit_s32 req_char_ptr; 369 /* Head of the last recursion. */ 370 sljit_s32 recursive_head_ptr; 371 /* First inspected character for partial matching. 372 (Needed for avoiding zero length partial matches.) */ 373 sljit_s32 start_used_ptr; 374 /* Starting pointer for partial soft matches. */ 375 sljit_s32 hit_start; 376 /* Pointer of the match end position. */ 377 sljit_s32 match_end_ptr; 378 /* Points to the marked string. */ 379 sljit_s32 mark_ptr; 380 /* Recursive control verb management chain. */ 381 sljit_s32 control_head_ptr; 382 /* Points to the last matched capture block index. */ 383 sljit_s32 capture_last_ptr; 384 /* Fast forward skipping byte code pointer. */ 385 PCRE2_SPTR fast_forward_bc_ptr; 386 /* Locals used by fast fail optimization. */ 387 sljit_s32 fast_fail_start_ptr; 388 sljit_s32 fast_fail_end_ptr; 389 390 /* Flipped and lower case tables. */ 391 const sljit_u8 *fcc; 392 sljit_sw lcc; 393 /* Mode can be PCRE2_JIT_COMPLETE and others. */ 394 int mode; 395 /* TRUE, when minlength is greater than 0. */ 396 BOOL might_be_empty; 397 /* \K is found in the pattern. */ 398 BOOL has_set_som; 399 /* (*SKIP:arg) is found in the pattern. */ 400 BOOL has_skip_arg; 401 /* (*THEN) is found in the pattern. */ 402 BOOL has_then; 403 /* (*SKIP) or (*SKIP:arg) is found in lookbehind assertion. */ 404 BOOL has_skip_in_assert_back; 405 /* Currently in recurse or negative assert. */ 406 BOOL local_exit; 407 /* Currently in a positive assert. */ 408 BOOL positive_assert; 409 /* Newline control. */ 410 int nltype; 411 sljit_u32 nlmax; 412 sljit_u32 nlmin; 413 int newline; 414 int bsr_nltype; 415 sljit_u32 bsr_nlmax; 416 sljit_u32 bsr_nlmin; 417 /* Dollar endonly. */ 418 int endonly; 419 /* Tables. */ 420 sljit_sw ctypes; 421 /* Named capturing brackets. */ 422 PCRE2_SPTR name_table; 423 sljit_sw name_count; 424 sljit_sw name_entry_size; 425 426 /* Labels and jump lists. */ 427 struct sljit_label *partialmatchlabel; 428 struct sljit_label *quit_label; 429 struct sljit_label *forced_quit_label; 430 struct sljit_label *accept_label; 431 struct sljit_label *ff_newline_shortcut; 432 stub_list *stubs; 433 label_addr_list *label_addrs; 434 recurse_entry *entries; 435 recurse_entry *currententry; 436 jump_list *partialmatch; 437 jump_list *quit; 438 jump_list *positive_assert_quit; 439 jump_list *forced_quit; 440 jump_list *accept; 441 jump_list *calllimit; 442 jump_list *stackalloc; 443 jump_list *revertframes; 444 jump_list *wordboundary; 445 jump_list *anynewline; 446 jump_list *hspace; 447 jump_list *vspace; 448 jump_list *casefulcmp; 449 jump_list *caselesscmp; 450 jump_list *reset_match; 451 BOOL unset_backref; 452 BOOL alt_circumflex; 453 #ifdef SUPPORT_UNICODE 454 BOOL utf; 455 BOOL use_ucp; 456 jump_list *getucd; 457 #if PCRE2_CODE_UNIT_WIDTH == 8 458 jump_list *utfreadchar; 459 jump_list *utfreadchar16; 460 jump_list *utfreadtype8; 461 #endif 462 #endif /* SUPPORT_UNICODE */ 463 } compiler_common; 464 465 /* For byte_sequence_compare. */ 466 467 typedef struct compare_context { 468 int length; 469 int sourcereg; 470 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED 471 int ucharptr; 472 union { 473 sljit_s32 asint; 474 sljit_u16 asushort; 475 #if PCRE2_CODE_UNIT_WIDTH == 8 476 sljit_u8 asbyte; 477 sljit_u8 asuchars[4]; 478 #elif PCRE2_CODE_UNIT_WIDTH == 16 479 sljit_u16 asuchars[2]; 480 #elif PCRE2_CODE_UNIT_WIDTH == 32 481 sljit_u32 asuchars[1]; 482 #endif 483 } c; 484 union { 485 sljit_s32 asint; 486 sljit_u16 asushort; 487 #if PCRE2_CODE_UNIT_WIDTH == 8 488 sljit_u8 asbyte; 489 sljit_u8 asuchars[4]; 490 #elif PCRE2_CODE_UNIT_WIDTH == 16 491 sljit_u16 asuchars[2]; 492 #elif PCRE2_CODE_UNIT_WIDTH == 32 493 sljit_u32 asuchars[1]; 494 #endif 495 } oc; 496 #endif 497 } compare_context; 498 499 /* Undefine sljit macros. */ 500 #undef CMP 501 502 /* Used for accessing the elements of the stack. */ 503 #define STACK(i) ((-(i) - 1) * (int)sizeof(sljit_sw)) 504 505 #define TMP1 SLJIT_R0 506 #define TMP2 SLJIT_R2 507 #define TMP3 SLJIT_R3 508 #define STR_PTR SLJIT_S0 509 #define STR_END SLJIT_S1 510 #define STACK_TOP SLJIT_R1 511 #define STACK_LIMIT SLJIT_S2 512 #define COUNT_MATCH SLJIT_S3 513 #define ARGUMENTS SLJIT_S4 514 #define RETURN_ADDR SLJIT_R4 515 516 /* Local space layout. */ 517 /* These two locals can be used by the current opcode. */ 518 #define LOCALS0 (0 * sizeof(sljit_sw)) 519 #define LOCALS1 (1 * sizeof(sljit_sw)) 520 /* Two local variables for possessive quantifiers (char1 cannot use them). */ 521 #define POSSESSIVE0 (2 * sizeof(sljit_sw)) 522 #define POSSESSIVE1 (3 * sizeof(sljit_sw)) 523 /* Max limit of recursions. */ 524 #define LIMIT_MATCH (4 * sizeof(sljit_sw)) 525 /* The output vector is stored on the stack, and contains pointers 526 to characters. The vector data is divided into two groups: the first 527 group contains the start / end character pointers, and the second is 528 the start pointers when the end of the capturing group has not yet reached. */ 529 #define OVECTOR_START (common->ovector_start) 530 #define OVECTOR(i) (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw)) 531 #define OVECTOR_PRIV(i) (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw)) 532 #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start]) 533 534 #if PCRE2_CODE_UNIT_WIDTH == 8 535 #define MOV_UCHAR SLJIT_MOV_U8 536 #define MOVU_UCHAR SLJIT_MOVU_U8 537 #define IN_UCHARS(x) (x) 538 #elif PCRE2_CODE_UNIT_WIDTH == 16 539 #define MOV_UCHAR SLJIT_MOV_U16 540 #define MOVU_UCHAR SLJIT_MOVU_U16 541 #define UCHAR_SHIFT (1) 542 #define IN_UCHARS(x) ((x) * 2) 543 #elif PCRE2_CODE_UNIT_WIDTH == 32 544 #define MOV_UCHAR SLJIT_MOV_U32 545 #define MOVU_UCHAR SLJIT_MOVU_U32 546 #define UCHAR_SHIFT (2) 547 #define IN_UCHARS(x) ((x) * 4) 548 #else 549 #error Unsupported compiling mode 550 #endif 551 552 /* Shortcuts. */ 553 #define DEFINE_COMPILER \ 554 struct sljit_compiler *compiler = common->compiler 555 #define OP1(op, dst, dstw, src, srcw) \ 556 sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw)) 557 #define OP2(op, dst, dstw, src1, src1w, src2, src2w) \ 558 sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w)) 559 #define LABEL() \ 560 sljit_emit_label(compiler) 561 #define JUMP(type) \ 562 sljit_emit_jump(compiler, (type)) 563 #define JUMPTO(type, label) \ 564 sljit_set_label(sljit_emit_jump(compiler, (type)), (label)) 565 #define JUMPHERE(jump) \ 566 sljit_set_label((jump), sljit_emit_label(compiler)) 567 #define SET_LABEL(jump, label) \ 568 sljit_set_label((jump), (label)) 569 #define CMP(type, src1, src1w, src2, src2w) \ 570 sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)) 571 #define CMPTO(type, src1, src1w, src2, src2w, label) \ 572 sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label)) 573 #define OP_FLAGS(op, dst, dstw, src, srcw, type) \ 574 sljit_emit_op_flags(compiler, (op), (dst), (dstw), (src), (srcw), (type)) 575 #define GET_LOCAL_BASE(dst, dstw, offset) \ 576 sljit_get_local_base(compiler, (dst), (dstw), (offset)) 577 578 #define READ_CHAR_MAX 0x7fffffff 579 580 static PCRE2_SPTR bracketend(PCRE2_SPTR cc) 581 { 582 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND)); 583 do cc += GET(cc, 1); while (*cc == OP_ALT); 584 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS); 585 cc += 1 + LINK_SIZE; 586 return cc; 587 } 588 589 static int no_alternatives(PCRE2_SPTR cc) 590 { 591 int count = 0; 592 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND)); 593 do 594 { 595 cc += GET(cc, 1); 596 count++; 597 } 598 while (*cc == OP_ALT); 599 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS); 600 return count; 601 } 602 603 /* Functions whose might need modification for all new supported opcodes: 604 next_opcode 605 check_opcode_types 606 set_private_data_ptrs 607 get_framesize 608 init_frame 609 get_private_data_copy_length 610 copy_private_data 611 compile_matchingpath 612 compile_backtrackingpath 613 */ 614 615 static PCRE2_SPTR next_opcode(compiler_common *common, PCRE2_SPTR cc) 616 { 617 SLJIT_UNUSED_ARG(common); 618 switch(*cc) 619 { 620 case OP_SOD: 621 case OP_SOM: 622 case OP_SET_SOM: 623 case OP_NOT_WORD_BOUNDARY: 624 case OP_WORD_BOUNDARY: 625 case OP_NOT_DIGIT: 626 case OP_DIGIT: 627 case OP_NOT_WHITESPACE: 628 case OP_WHITESPACE: 629 case OP_NOT_WORDCHAR: 630 case OP_WORDCHAR: 631 case OP_ANY: 632 case OP_ALLANY: 633 case OP_NOTPROP: 634 case OP_PROP: 635 case OP_ANYNL: 636 case OP_NOT_HSPACE: 637 case OP_HSPACE: 638 case OP_NOT_VSPACE: 639 case OP_VSPACE: 640 case OP_EXTUNI: 641 case OP_EODN: 642 case OP_EOD: 643 case OP_CIRC: 644 case OP_CIRCM: 645 case OP_DOLL: 646 case OP_DOLLM: 647 case OP_CRSTAR: 648 case OP_CRMINSTAR: 649 case OP_CRPLUS: 650 case OP_CRMINPLUS: 651 case OP_CRQUERY: 652 case OP_CRMINQUERY: 653 case OP_CRRANGE: 654 case OP_CRMINRANGE: 655 case OP_CRPOSSTAR: 656 case OP_CRPOSPLUS: 657 case OP_CRPOSQUERY: 658 case OP_CRPOSRANGE: 659 case OP_CLASS: 660 case OP_NCLASS: 661 case OP_REF: 662 case OP_REFI: 663 case OP_DNREF: 664 case OP_DNREFI: 665 case OP_RECURSE: 666 case OP_CALLOUT: 667 case OP_ALT: 668 case OP_KET: 669 case OP_KETRMAX: 670 case OP_KETRMIN: 671 case OP_KETRPOS: 672 case OP_REVERSE: 673 case OP_ASSERT: 674 case OP_ASSERT_NOT: 675 case OP_ASSERTBACK: 676 case OP_ASSERTBACK_NOT: 677 case OP_ONCE: 678 case OP_ONCE_NC: 679 case OP_BRA: 680 case OP_BRAPOS: 681 case OP_CBRA: 682 case OP_CBRAPOS: 683 case OP_COND: 684 case OP_SBRA: 685 case OP_SBRAPOS: 686 case OP_SCBRA: 687 case OP_SCBRAPOS: 688 case OP_SCOND: 689 case OP_CREF: 690 case OP_DNCREF: 691 case OP_RREF: 692 case OP_DNRREF: 693 case OP_FALSE: 694 case OP_TRUE: 695 case OP_BRAZERO: 696 case OP_BRAMINZERO: 697 case OP_BRAPOSZERO: 698 case OP_PRUNE: 699 case OP_SKIP: 700 case OP_THEN: 701 case OP_COMMIT: 702 case OP_FAIL: 703 case OP_ACCEPT: 704 case OP_ASSERT_ACCEPT: 705 case OP_CLOSE: 706 case OP_SKIPZERO: 707 return cc + PRIV(OP_lengths)[*cc]; 708 709 case OP_CHAR: 710 case OP_CHARI: 711 case OP_NOT: 712 case OP_NOTI: 713 case OP_STAR: 714 case OP_MINSTAR: 715 case OP_PLUS: 716 case OP_MINPLUS: 717 case OP_QUERY: 718 case OP_MINQUERY: 719 case OP_UPTO: 720 case OP_MINUPTO: 721 case OP_EXACT: 722 case OP_POSSTAR: 723 case OP_POSPLUS: 724 case OP_POSQUERY: 725 case OP_POSUPTO: 726 case OP_STARI: 727 case OP_MINSTARI: 728 case OP_PLUSI: 729 case OP_MINPLUSI: 730 case OP_QUERYI: 731 case OP_MINQUERYI: 732 case OP_UPTOI: 733 case OP_MINUPTOI: 734 case OP_EXACTI: 735 case OP_POSSTARI: 736 case OP_POSPLUSI: 737 case OP_POSQUERYI: 738 case OP_POSUPTOI: 739 case OP_NOTSTAR: 740 case OP_NOTMINSTAR: 741 case OP_NOTPLUS: 742 case OP_NOTMINPLUS: 743 case OP_NOTQUERY: 744 case OP_NOTMINQUERY: 745 case OP_NOTUPTO: 746 case OP_NOTMINUPTO: 747 case OP_NOTEXACT: 748 case OP_NOTPOSSTAR: 749 case OP_NOTPOSPLUS: 750 case OP_NOTPOSQUERY: 751 case OP_NOTPOSUPTO: 752 case OP_NOTSTARI: 753 case OP_NOTMINSTARI: 754 case OP_NOTPLUSI: 755 case OP_NOTMINPLUSI: 756 case OP_NOTQUERYI: 757 case OP_NOTMINQUERYI: 758 case OP_NOTUPTOI: 759 case OP_NOTMINUPTOI: 760 case OP_NOTEXACTI: 761 case OP_NOTPOSSTARI: 762 case OP_NOTPOSPLUSI: 763 case OP_NOTPOSQUERYI: 764 case OP_NOTPOSUPTOI: 765 cc += PRIV(OP_lengths)[*cc]; 766 #ifdef SUPPORT_UNICODE 767 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 768 #endif 769 return cc; 770 771 /* Special cases. */ 772 case OP_TYPESTAR: 773 case OP_TYPEMINSTAR: 774 case OP_TYPEPLUS: 775 case OP_TYPEMINPLUS: 776 case OP_TYPEQUERY: 777 case OP_TYPEMINQUERY: 778 case OP_TYPEUPTO: 779 case OP_TYPEMINUPTO: 780 case OP_TYPEEXACT: 781 case OP_TYPEPOSSTAR: 782 case OP_TYPEPOSPLUS: 783 case OP_TYPEPOSQUERY: 784 case OP_TYPEPOSUPTO: 785 return cc + PRIV(OP_lengths)[*cc] - 1; 786 787 case OP_ANYBYTE: 788 #ifdef SUPPORT_UNICODE 789 if (common->utf) return NULL; 790 #endif 791 return cc + 1; 792 793 case OP_CALLOUT_STR: 794 return cc + GET(cc, 1 + 2*LINK_SIZE); 795 796 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 797 case OP_XCLASS: 798 return cc + GET(cc, 1); 799 #endif 800 801 case OP_MARK: 802 case OP_PRUNE_ARG: 803 case OP_SKIP_ARG: 804 case OP_THEN_ARG: 805 return cc + 1 + 2 + cc[1]; 806 807 default: 808 /* All opcodes are supported now! */ 809 SLJIT_ASSERT_STOP(); 810 return NULL; 811 } 812 } 813 814 static BOOL check_opcode_types(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend) 815 { 816 int count; 817 PCRE2_SPTR slot; 818 PCRE2_SPTR assert_back_end = cc - 1; 819 820 /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */ 821 while (cc < ccend) 822 { 823 switch(*cc) 824 { 825 case OP_SET_SOM: 826 common->has_set_som = TRUE; 827 common->might_be_empty = TRUE; 828 cc += 1; 829 break; 830 831 case OP_REF: 832 case OP_REFI: 833 common->optimized_cbracket[GET2(cc, 1)] = 0; 834 cc += 1 + IMM2_SIZE; 835 break; 836 837 case OP_CBRAPOS: 838 case OP_SCBRAPOS: 839 common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0; 840 cc += 1 + LINK_SIZE + IMM2_SIZE; 841 break; 842 843 case OP_COND: 844 case OP_SCOND: 845 /* Only AUTO_CALLOUT can insert this opcode. We do 846 not intend to support this case. */ 847 if (cc[1 + LINK_SIZE] == OP_CALLOUT || cc[1 + LINK_SIZE] == OP_CALLOUT_STR) 848 return FALSE; 849 cc += 1 + LINK_SIZE; 850 break; 851 852 case OP_CREF: 853 common->optimized_cbracket[GET2(cc, 1)] = 0; 854 cc += 1 + IMM2_SIZE; 855 break; 856 857 case OP_DNREF: 858 case OP_DNREFI: 859 case OP_DNCREF: 860 count = GET2(cc, 1 + IMM2_SIZE); 861 slot = common->name_table + GET2(cc, 1) * common->name_entry_size; 862 while (count-- > 0) 863 { 864 common->optimized_cbracket[GET2(slot, 0)] = 0; 865 slot += common->name_entry_size; 866 } 867 cc += 1 + 2 * IMM2_SIZE; 868 break; 869 870 case OP_RECURSE: 871 /* Set its value only once. */ 872 if (common->recursive_head_ptr == 0) 873 { 874 common->recursive_head_ptr = common->ovector_start; 875 common->ovector_start += sizeof(sljit_sw); 876 } 877 cc += 1 + LINK_SIZE; 878 break; 879 880 case OP_CALLOUT: 881 case OP_CALLOUT_STR: 882 if (common->capture_last_ptr == 0) 883 { 884 common->capture_last_ptr = common->ovector_start; 885 common->ovector_start += sizeof(sljit_sw); 886 } 887 cc += (*cc == OP_CALLOUT) ? PRIV(OP_lengths)[OP_CALLOUT] : GET(cc, 1 + 2*LINK_SIZE); 888 break; 889 890 case OP_ASSERTBACK: 891 slot = bracketend(cc); 892 if (slot > assert_back_end) 893 assert_back_end = slot; 894 cc += 1 + LINK_SIZE; 895 break; 896 897 case OP_THEN_ARG: 898 common->has_then = TRUE; 899 common->control_head_ptr = 1; 900 /* Fall through. */ 901 902 case OP_PRUNE_ARG: 903 case OP_MARK: 904 if (common->mark_ptr == 0) 905 { 906 common->mark_ptr = common->ovector_start; 907 common->ovector_start += sizeof(sljit_sw); 908 } 909 cc += 1 + 2 + cc[1]; 910 break; 911 912 case OP_THEN: 913 common->has_then = TRUE; 914 common->control_head_ptr = 1; 915 cc += 1; 916 break; 917 918 case OP_SKIP: 919 if (cc < assert_back_end) 920 common->has_skip_in_assert_back = TRUE; 921 cc += 1; 922 break; 923 924 case OP_SKIP_ARG: 925 common->control_head_ptr = 1; 926 common->has_skip_arg = TRUE; 927 if (cc < assert_back_end) 928 common->has_skip_in_assert_back = TRUE; 929 cc += 1 + 2 + cc[1]; 930 break; 931 932 default: 933 cc = next_opcode(common, cc); 934 if (cc == NULL) 935 return FALSE; 936 break; 937 } 938 } 939 return TRUE; 940 } 941 942 static BOOL is_accelerated_repeat(PCRE2_SPTR cc) 943 { 944 switch(*cc) 945 { 946 case OP_TYPESTAR: 947 case OP_TYPEMINSTAR: 948 case OP_TYPEPLUS: 949 case OP_TYPEMINPLUS: 950 case OP_TYPEPOSSTAR: 951 case OP_TYPEPOSPLUS: 952 return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI); 953 954 case OP_STAR: 955 case OP_MINSTAR: 956 case OP_PLUS: 957 case OP_MINPLUS: 958 case OP_POSSTAR: 959 case OP_POSPLUS: 960 961 case OP_STARI: 962 case OP_MINSTARI: 963 case OP_PLUSI: 964 case OP_MINPLUSI: 965 case OP_POSSTARI: 966 case OP_POSPLUSI: 967 968 case OP_NOTSTAR: 969 case OP_NOTMINSTAR: 970 case OP_NOTPLUS: 971 case OP_NOTMINPLUS: 972 case OP_NOTPOSSTAR: 973 case OP_NOTPOSPLUS: 974 975 case OP_NOTSTARI: 976 case OP_NOTMINSTARI: 977 case OP_NOTPLUSI: 978 case OP_NOTMINPLUSI: 979 case OP_NOTPOSSTARI: 980 case OP_NOTPOSPLUSI: 981 return TRUE; 982 983 case OP_CLASS: 984 case OP_NCLASS: 985 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 986 case OP_XCLASS: 987 cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(PCRE2_UCHAR))); 988 #else 989 cc += (1 + (32 / sizeof(PCRE2_UCHAR))); 990 #endif 991 992 switch(*cc) 993 { 994 case OP_CRSTAR: 995 case OP_CRMINSTAR: 996 case OP_CRPLUS: 997 case OP_CRMINPLUS: 998 case OP_CRPOSSTAR: 999 case OP_CRPOSPLUS: 1000 return TRUE; 1001 } 1002 break; 1003 } 1004 return FALSE; 1005 } 1006 1007 static SLJIT_INLINE BOOL detect_fast_forward_skip(compiler_common *common, int *private_data_start) 1008 { 1009 PCRE2_SPTR cc = common->start; 1010 PCRE2_SPTR end; 1011 1012 /* Skip not repeated brackets. */ 1013 while (TRUE) 1014 { 1015 switch(*cc) 1016 { 1017 case OP_SOD: 1018 case OP_SOM: 1019 case OP_SET_SOM: 1020 case OP_NOT_WORD_BOUNDARY: 1021 case OP_WORD_BOUNDARY: 1022 case OP_EODN: 1023 case OP_EOD: 1024 case OP_CIRC: 1025 case OP_CIRCM: 1026 case OP_DOLL: 1027 case OP_DOLLM: 1028 /* Zero width assertions. */ 1029 cc++; 1030 continue; 1031 } 1032 1033 if (*cc != OP_BRA && *cc != OP_CBRA) 1034 break; 1035 1036 end = cc + GET(cc, 1); 1037 if (*end != OP_KET || PRIVATE_DATA(end) != 0) 1038 return FALSE; 1039 if (*cc == OP_CBRA) 1040 { 1041 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) 1042 return FALSE; 1043 cc += IMM2_SIZE; 1044 } 1045 cc += 1 + LINK_SIZE; 1046 } 1047 1048 if (is_accelerated_repeat(cc)) 1049 { 1050 common->fast_forward_bc_ptr = cc; 1051 common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start; 1052 *private_data_start += sizeof(sljit_sw); 1053 return TRUE; 1054 } 1055 return FALSE; 1056 } 1057 1058 static SLJIT_INLINE void detect_fast_fail(compiler_common *common, PCRE2_SPTR cc, int *private_data_start, sljit_s32 depth) 1059 { 1060 PCRE2_SPTR next_alt; 1061 1062 SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA); 1063 1064 if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) 1065 return; 1066 1067 next_alt = bracketend(cc) - (1 + LINK_SIZE); 1068 if (*next_alt != OP_KET || PRIVATE_DATA(next_alt) != 0) 1069 return; 1070 1071 do 1072 { 1073 next_alt = cc + GET(cc, 1); 1074 1075 cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0); 1076 1077 while (TRUE) 1078 { 1079 switch(*cc) 1080 { 1081 case OP_SOD: 1082 case OP_SOM: 1083 case OP_SET_SOM: 1084 case OP_NOT_WORD_BOUNDARY: 1085 case OP_WORD_BOUNDARY: 1086 case OP_EODN: 1087 case OP_EOD: 1088 case OP_CIRC: 1089 case OP_CIRCM: 1090 case OP_DOLL: 1091 case OP_DOLLM: 1092 /* Zero width assertions. */ 1093 cc++; 1094 continue; 1095 } 1096 break; 1097 } 1098 1099 if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA)) 1100 detect_fast_fail(common, cc, private_data_start, depth - 1); 1101 1102 if (is_accelerated_repeat(cc)) 1103 { 1104 common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start; 1105 1106 if (common->fast_fail_start_ptr == 0) 1107 common->fast_fail_start_ptr = *private_data_start; 1108 1109 *private_data_start += sizeof(sljit_sw); 1110 common->fast_fail_end_ptr = *private_data_start; 1111 1112 if (*private_data_start > SLJIT_MAX_LOCAL_SIZE) 1113 return; 1114 } 1115 1116 cc = next_alt; 1117 } 1118 while (*cc == OP_ALT); 1119 } 1120 1121 static int get_class_iterator_size(PCRE2_SPTR cc) 1122 { 1123 sljit_u32 min; 1124 sljit_u32 max; 1125 switch(*cc) 1126 { 1127 case OP_CRSTAR: 1128 case OP_CRPLUS: 1129 return 2; 1130 1131 case OP_CRMINSTAR: 1132 case OP_CRMINPLUS: 1133 case OP_CRQUERY: 1134 case OP_CRMINQUERY: 1135 return 1; 1136 1137 case OP_CRRANGE: 1138 case OP_CRMINRANGE: 1139 min = GET2(cc, 1); 1140 max = GET2(cc, 1 + IMM2_SIZE); 1141 if (max == 0) 1142 return (*cc == OP_CRRANGE) ? 2 : 1; 1143 max -= min; 1144 if (max > 2) 1145 max = 2; 1146 return max; 1147 1148 default: 1149 return 0; 1150 } 1151 } 1152 1153 static BOOL detect_repeat(compiler_common *common, PCRE2_SPTR begin) 1154 { 1155 PCRE2_SPTR end = bracketend(begin); 1156 PCRE2_SPTR next; 1157 PCRE2_SPTR next_end; 1158 PCRE2_SPTR max_end; 1159 PCRE2_UCHAR type; 1160 sljit_sw length = end - begin; 1161 sljit_s32 min, max, i; 1162 1163 /* Detect fixed iterations first. */ 1164 if (end[-(1 + LINK_SIZE)] != OP_KET) 1165 return FALSE; 1166 1167 /* Already detected repeat. */ 1168 if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0) 1169 return TRUE; 1170 1171 next = end; 1172 min = 1; 1173 while (1) 1174 { 1175 if (*next != *begin) 1176 break; 1177 next_end = bracketend(next); 1178 if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0) 1179 break; 1180 next = next_end; 1181 min++; 1182 } 1183 1184 if (min == 2) 1185 return FALSE; 1186 1187 max = 0; 1188 max_end = next; 1189 if (*next == OP_BRAZERO || *next == OP_BRAMINZERO) 1190 { 1191 type = *next; 1192 while (1) 1193 { 1194 if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin) 1195 break; 1196 next_end = bracketend(next + 2 + LINK_SIZE); 1197 if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0) 1198 break; 1199 next = next_end; 1200 max++; 1201 } 1202 1203 if (next[0] == type && next[1] == *begin && max >= 1) 1204 { 1205 next_end = bracketend(next + 1); 1206 if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0) 1207 { 1208 for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE) 1209 if (*next_end != OP_KET) 1210 break; 1211 1212 if (i == max) 1213 { 1214 common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end; 1215 common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO; 1216 /* +2 the original and the last. */ 1217 common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2; 1218 if (min == 1) 1219 return TRUE; 1220 min--; 1221 max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE); 1222 } 1223 } 1224 } 1225 } 1226 1227 if (min >= 3) 1228 { 1229 common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end; 1230 common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT; 1231 common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min; 1232 return TRUE; 1233 } 1234 1235 return FALSE; 1236 } 1237 1238 #define CASE_ITERATOR_PRIVATE_DATA_1 \ 1239 case OP_MINSTAR: \ 1240 case OP_MINPLUS: \ 1241 case OP_QUERY: \ 1242 case OP_MINQUERY: \ 1243 case OP_MINSTARI: \ 1244 case OP_MINPLUSI: \ 1245 case OP_QUERYI: \ 1246 case OP_MINQUERYI: \ 1247 case OP_NOTMINSTAR: \ 1248 case OP_NOTMINPLUS: \ 1249 case OP_NOTQUERY: \ 1250 case OP_NOTMINQUERY: \ 1251 case OP_NOTMINSTARI: \ 1252 case OP_NOTMINPLUSI: \ 1253 case OP_NOTQUERYI: \ 1254 case OP_NOTMINQUERYI: 1255 1256 #define CASE_ITERATOR_PRIVATE_DATA_2A \ 1257 case OP_STAR: \ 1258 case OP_PLUS: \ 1259 case OP_STARI: \ 1260 case OP_PLUSI: \ 1261 case OP_NOTSTAR: \ 1262 case OP_NOTPLUS: \ 1263 case OP_NOTSTARI: \ 1264 case OP_NOTPLUSI: 1265 1266 #define CASE_ITERATOR_PRIVATE_DATA_2B \ 1267 case OP_UPTO: \ 1268 case OP_MINUPTO: \ 1269 case OP_UPTOI: \ 1270 case OP_MINUPTOI: \ 1271 case OP_NOTUPTO: \ 1272 case OP_NOTMINUPTO: \ 1273 case OP_NOTUPTOI: \ 1274 case OP_NOTMINUPTOI: 1275 1276 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \ 1277 case OP_TYPEMINSTAR: \ 1278 case OP_TYPEMINPLUS: \ 1279 case OP_TYPEQUERY: \ 1280 case OP_TYPEMINQUERY: 1281 1282 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \ 1283 case OP_TYPESTAR: \ 1284 case OP_TYPEPLUS: 1285 1286 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \ 1287 case OP_TYPEUPTO: \ 1288 case OP_TYPEMINUPTO: 1289 1290 static void set_private_data_ptrs(compiler_common *common, int *private_data_start, PCRE2_SPTR ccend) 1291 { 1292 PCRE2_SPTR cc = common->start; 1293 PCRE2_SPTR alternative; 1294 PCRE2_SPTR end = NULL; 1295 int private_data_ptr = *private_data_start; 1296 int space, size, bracketlen; 1297 BOOL repeat_check = TRUE; 1298 1299 while (cc < ccend) 1300 { 1301 space = 0; 1302 size = 0; 1303 bracketlen = 0; 1304 if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE) 1305 break; 1306 1307 if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)) 1308 { 1309 if (detect_repeat(common, cc)) 1310 { 1311 /* These brackets are converted to repeats, so no global 1312 based single character repeat is allowed. */ 1313 if (cc >= end) 1314 end = bracketend(cc); 1315 } 1316 } 1317 repeat_check = TRUE; 1318 1319 switch(*cc) 1320 { 1321 case OP_KET: 1322 if (common->private_data_ptrs[cc + 1 - common->start] != 0) 1323 { 1324 common->private_data_ptrs[cc - common->start] = private_data_ptr; 1325 private_data_ptr += sizeof(sljit_sw); 1326 cc += common->private_data_ptrs[cc + 1 - common->start]; 1327 } 1328 cc += 1 + LINK_SIZE; 1329 break; 1330 1331 case OP_ASSERT: 1332 case OP_ASSERT_NOT: 1333 case OP_ASSERTBACK: 1334 case OP_ASSERTBACK_NOT: 1335 case OP_ONCE: 1336 case OP_ONCE_NC: 1337 case OP_BRAPOS: 1338 case OP_SBRA: 1339 case OP_SBRAPOS: 1340 case OP_SCOND: 1341 common->private_data_ptrs[cc - common->start] = private_data_ptr; 1342 private_data_ptr += sizeof(sljit_sw); 1343 bracketlen = 1 + LINK_SIZE; 1344 break; 1345 1346 case OP_CBRAPOS: 1347 case OP_SCBRAPOS: 1348 common->private_data_ptrs[cc - common->start] = private_data_ptr; 1349 private_data_ptr += sizeof(sljit_sw); 1350 bracketlen = 1 + LINK_SIZE + IMM2_SIZE; 1351 break; 1352 1353 case OP_COND: 1354 /* Might be a hidden SCOND. */ 1355 alternative = cc + GET(cc, 1); 1356 if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) 1357 { 1358 common->private_data_ptrs[cc - common->start] = private_data_ptr; 1359 private_data_ptr += sizeof(sljit_sw); 1360 } 1361 bracketlen = 1 + LINK_SIZE; 1362 break; 1363 1364 case OP_BRA: 1365 bracketlen = 1 + LINK_SIZE; 1366 break; 1367 1368 case OP_CBRA: 1369 case OP_SCBRA: 1370 bracketlen = 1 + LINK_SIZE + IMM2_SIZE; 1371 break; 1372 1373 case OP_BRAZERO: 1374 case OP_BRAMINZERO: 1375 case OP_BRAPOSZERO: 1376 repeat_check = FALSE; 1377 size = 1; 1378 break; 1379 1380 CASE_ITERATOR_PRIVATE_DATA_1 1381 space = 1; 1382 size = -2; 1383 break; 1384 1385 CASE_ITERATOR_PRIVATE_DATA_2A 1386 space = 2; 1387 size = -2; 1388 break; 1389 1390 CASE_ITERATOR_PRIVATE_DATA_2B 1391 space = 2; 1392 size = -(2 + IMM2_SIZE); 1393 break; 1394 1395 CASE_ITERATOR_TYPE_PRIVATE_DATA_1 1396 space = 1; 1397 size = 1; 1398 break; 1399 1400 CASE_ITERATOR_TYPE_PRIVATE_DATA_2A 1401 if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI) 1402 space = 2; 1403 size = 1; 1404 break; 1405 1406 case OP_TYPEUPTO: 1407 if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI) 1408 space = 2; 1409 size = 1 + IMM2_SIZE; 1410 break; 1411 1412 case OP_TYPEMINUPTO: 1413 space = 2; 1414 size = 1 + IMM2_SIZE; 1415 break; 1416 1417 case OP_CLASS: 1418 case OP_NCLASS: 1419 space = get_class_iterator_size(cc + size); 1420 size = 1 + 32 / sizeof(PCRE2_UCHAR); 1421 break; 1422 1423 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 1424 case OP_XCLASS: 1425 space = get_class_iterator_size(cc + size); 1426 size = GET(cc, 1); 1427 break; 1428 #endif 1429 1430 default: 1431 cc = next_opcode(common, cc); 1432 SLJIT_ASSERT(cc != NULL); 1433 break; 1434 } 1435 1436 /* Character iterators, which are not inside a repeated bracket, 1437 gets a private slot instead of allocating it on the stack. */ 1438 if (space > 0 && cc >= end) 1439 { 1440 common->private_data_ptrs[cc - common->start] = private_data_ptr; 1441 private_data_ptr += sizeof(sljit_sw) * space; 1442 } 1443 1444 if (size != 0) 1445 { 1446 if (size < 0) 1447 { 1448 cc += -size; 1449 #ifdef SUPPORT_UNICODE 1450 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 1451 #endif 1452 } 1453 else 1454 cc += size; 1455 } 1456 1457 if (bracketlen > 0) 1458 { 1459 if (cc >= end) 1460 { 1461 end = bracketend(cc); 1462 if (end[-1 - LINK_SIZE] == OP_KET) 1463 end = NULL; 1464 } 1465 cc += bracketlen; 1466 } 1467 } 1468 *private_data_start = private_data_ptr; 1469 } 1470 1471 /* Returns with a frame_types (always < 0) if no need for frame. */ 1472 static int get_framesize(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, BOOL recursive, BOOL *needs_control_head) 1473 { 1474 int length = 0; 1475 int possessive = 0; 1476 BOOL stack_restore = FALSE; 1477 BOOL setsom_found = recursive; 1478 BOOL setmark_found = recursive; 1479 /* The last capture is a local variable even for recursions. */ 1480 BOOL capture_last_found = FALSE; 1481 1482 #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD 1483 SLJIT_ASSERT(common->control_head_ptr != 0); 1484 *needs_control_head = TRUE; 1485 #else 1486 *needs_control_head = FALSE; 1487 #endif 1488 1489 if (ccend == NULL) 1490 { 1491 ccend = bracketend(cc) - (1 + LINK_SIZE); 1492 if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS)) 1493 { 1494 possessive = length = (common->capture_last_ptr != 0) ? 5 : 3; 1495 /* This is correct regardless of common->capture_last_ptr. */ 1496 capture_last_found = TRUE; 1497 } 1498 cc = next_opcode(common, cc); 1499 } 1500 1501 SLJIT_ASSERT(cc != NULL); 1502 while (cc < ccend) 1503 switch(*cc) 1504 { 1505 case OP_SET_SOM: 1506 SLJIT_ASSERT(common->has_set_som); 1507 stack_restore = TRUE; 1508 if (!setsom_found) 1509 { 1510 length += 2; 1511 setsom_found = TRUE; 1512 } 1513 cc += 1; 1514 break; 1515 1516 case OP_MARK: 1517 case OP_PRUNE_ARG: 1518 case OP_THEN_ARG: 1519 SLJIT_ASSERT(common->mark_ptr != 0); 1520 stack_restore = TRUE; 1521 if (!setmark_found) 1522 { 1523 length += 2; 1524 setmark_found = TRUE; 1525 } 1526 if (common->control_head_ptr != 0) 1527 *needs_control_head = TRUE; 1528 cc += 1 + 2 + cc[1]; 1529 break; 1530 1531 case OP_RECURSE: 1532 stack_restore = TRUE; 1533 if (common->has_set_som && !setsom_found) 1534 { 1535 length += 2; 1536 setsom_found = TRUE; 1537 } 1538 if (common->mark_ptr != 0 && !setmark_found) 1539 { 1540 length += 2; 1541 setmark_found = TRUE; 1542 } 1543 if (common->capture_last_ptr != 0 && !capture_last_found) 1544 { 1545 length += 2; 1546 capture_last_found = TRUE; 1547 } 1548 cc += 1 + LINK_SIZE; 1549 break; 1550 1551 case OP_CBRA: 1552 case OP_CBRAPOS: 1553 case OP_SCBRA: 1554 case OP_SCBRAPOS: 1555 stack_restore = TRUE; 1556 if (common->capture_last_ptr != 0 && !capture_last_found) 1557 { 1558 length += 2; 1559 capture_last_found = TRUE; 1560 } 1561 length += 3; 1562 cc += 1 + LINK_SIZE + IMM2_SIZE; 1563 break; 1564 1565 case OP_THEN: 1566 stack_restore = TRUE; 1567 if (common->control_head_ptr != 0) 1568 *needs_control_head = TRUE; 1569 cc ++; 1570 break; 1571 1572 default: 1573 stack_restore = TRUE; 1574 /* Fall through. */ 1575 1576 case OP_NOT_WORD_BOUNDARY: 1577 case OP_WORD_BOUNDARY: 1578 case OP_NOT_DIGIT: 1579 case OP_DIGIT: 1580 case OP_NOT_WHITESPACE: 1581 case OP_WHITESPACE: 1582 case OP_NOT_WORDCHAR: 1583 case OP_WORDCHAR: 1584 case OP_ANY: 1585 case OP_ALLANY: 1586 case OP_ANYBYTE: 1587 case OP_NOTPROP: 1588 case OP_PROP: 1589 case OP_ANYNL: 1590 case OP_NOT_HSPACE: 1591 case OP_HSPACE: 1592 case OP_NOT_VSPACE: 1593 case OP_VSPACE: 1594 case OP_EXTUNI: 1595 case OP_EODN: 1596 case OP_EOD: 1597 case OP_CIRC: 1598 case OP_CIRCM: 1599 case OP_DOLL: 1600 case OP_DOLLM: 1601 case OP_CHAR: 1602 case OP_CHARI: 1603 case OP_NOT: 1604 case OP_NOTI: 1605 1606 case OP_EXACT: 1607 case OP_POSSTAR: 1608 case OP_POSPLUS: 1609 case OP_POSQUERY: 1610 case OP_POSUPTO: 1611 1612 case OP_EXACTI: 1613 case OP_POSSTARI: 1614 case OP_POSPLUSI: 1615 case OP_POSQUERYI: 1616 case OP_POSUPTOI: 1617 1618 case OP_NOTEXACT: 1619 case OP_NOTPOSSTAR: 1620 case OP_NOTPOSPLUS: 1621 case OP_NOTPOSQUERY: 1622 case OP_NOTPOSUPTO: 1623 1624 case OP_NOTEXACTI: 1625 case OP_NOTPOSSTARI: 1626 case OP_NOTPOSPLUSI: 1627 case OP_NOTPOSQUERYI: 1628 case OP_NOTPOSUPTOI: 1629 1630 case OP_TYPEEXACT: 1631 case OP_TYPEPOSSTAR: 1632 case OP_TYPEPOSPLUS: 1633 case OP_TYPEPOSQUERY: 1634 case OP_TYPEPOSUPTO: 1635 1636 case OP_CLASS: 1637 case OP_NCLASS: 1638 case OP_XCLASS: 1639 1640 case OP_CALLOUT: 1641 case OP_CALLOUT_STR: 1642 1643 cc = next_opcode(common, cc); 1644 SLJIT_ASSERT(cc != NULL); 1645 break; 1646 } 1647 1648 /* Possessive quantifiers can use a special case. */ 1649 if (SLJIT_UNLIKELY(possessive == length)) 1650 return stack_restore ? no_frame : no_stack; 1651 1652 if (length > 0) 1653 return length + 1; 1654 return stack_restore ? no_frame : no_stack; 1655 } 1656 1657 static void init_frame(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, int stackpos, int stacktop, BOOL recursive) 1658 { 1659 DEFINE_COMPILER; 1660 BOOL setsom_found = recursive; 1661 BOOL setmark_found = recursive; 1662 /* The last capture is a local variable even for recursions. */ 1663 BOOL capture_last_found = FALSE; 1664 int offset; 1665 1666 /* >= 1 + shortest item size (2) */ 1667 SLJIT_UNUSED_ARG(stacktop); 1668 SLJIT_ASSERT(stackpos >= stacktop + 2); 1669 1670 stackpos = STACK(stackpos); 1671 if (ccend == NULL) 1672 { 1673 ccend = bracketend(cc) - (1 + LINK_SIZE); 1674 if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS)) 1675 cc = next_opcode(common, cc); 1676 } 1677 1678 SLJIT_ASSERT(cc != NULL); 1679 while (cc < ccend) 1680 switch(*cc) 1681 { 1682 case OP_SET_SOM: 1683 SLJIT_ASSERT(common->has_set_som); 1684 if (!setsom_found) 1685 { 1686 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0)); 1687 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0)); 1688 stackpos += (int)sizeof(sljit_sw); 1689 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1690 stackpos += (int)sizeof(sljit_sw); 1691 setsom_found = TRUE; 1692 } 1693 cc += 1; 1694 break; 1695 1696 case OP_MARK: 1697 case OP_PRUNE_ARG: 1698 case OP_THEN_ARG: 1699 SLJIT_ASSERT(common->mark_ptr != 0); 1700 if (!setmark_found) 1701 { 1702 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr); 1703 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr); 1704 stackpos += (int)sizeof(sljit_sw); 1705 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1706 stackpos += (int)sizeof(sljit_sw); 1707 setmark_found = TRUE; 1708 } 1709 cc += 1 + 2 + cc[1]; 1710 break; 1711 1712 case OP_RECURSE: 1713 if (common->has_set_som && !setsom_found) 1714 { 1715 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0)); 1716 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0)); 1717 stackpos += (int)sizeof(sljit_sw); 1718 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1719 stackpos += (int)sizeof(sljit_sw); 1720 setsom_found = TRUE; 1721 } 1722 if (common->mark_ptr != 0 && !setmark_found) 1723 { 1724 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr); 1725 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr); 1726 stackpos += (int)sizeof(sljit_sw); 1727 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1728 stackpos += (int)sizeof(sljit_sw); 1729 setmark_found = TRUE; 1730 } 1731 if (common->capture_last_ptr != 0 && !capture_last_found) 1732 { 1733 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr); 1734 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr); 1735 stackpos += (int)sizeof(sljit_sw); 1736 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1737 stackpos += (int)sizeof(sljit_sw); 1738 capture_last_found = TRUE; 1739 } 1740 cc += 1 + LINK_SIZE; 1741 break; 1742 1743 case OP_CBRA: 1744 case OP_CBRAPOS: 1745 case OP_SCBRA: 1746 case OP_SCBRAPOS: 1747 if (common->capture_last_ptr != 0 && !capture_last_found) 1748 { 1749 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr); 1750 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr); 1751 stackpos += (int)sizeof(sljit_sw); 1752 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1753 stackpos += (int)sizeof(sljit_sw); 1754 capture_last_found = TRUE; 1755 } 1756 offset = (GET2(cc, 1 + LINK_SIZE)) << 1; 1757 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset)); 1758 stackpos += (int)sizeof(sljit_sw); 1759 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset)); 1760 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1)); 1761 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0); 1762 stackpos += (int)sizeof(sljit_sw); 1763 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0); 1764 stackpos += (int)sizeof(sljit_sw); 1765 1766 cc += 1 + LINK_SIZE + IMM2_SIZE; 1767 break; 1768 1769 default: 1770 cc = next_opcode(common, cc); 1771 SLJIT_ASSERT(cc != NULL); 1772 break; 1773 } 1774 1775 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0); 1776 SLJIT_ASSERT(stackpos == STACK(stacktop)); 1777 } 1778 1779 static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, BOOL needs_control_head) 1780 { 1781 int private_data_length = needs_control_head ? 3 : 2; 1782 int size; 1783 PCRE2_SPTR alternative; 1784 /* Calculate the sum of the private machine words. */ 1785 while (cc < ccend) 1786 { 1787 size = 0; 1788 switch(*cc) 1789 { 1790 case OP_KET: 1791 if (PRIVATE_DATA(cc) != 0) 1792 { 1793 private_data_length++; 1794 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0); 1795 cc += PRIVATE_DATA(cc + 1); 1796 } 1797 cc += 1 + LINK_SIZE; 1798 break; 1799 1800 case OP_ASSERT: 1801 case OP_ASSERT_NOT: 1802 case OP_ASSERTBACK: 1803 case OP_ASSERTBACK_NOT: 1804 case OP_ONCE: 1805 case OP_ONCE_NC: 1806 case OP_BRAPOS: 1807 case OP_SBRA: 1808 case OP_SBRAPOS: 1809 case OP_SCOND: 1810 private_data_length++; 1811 SLJIT_ASSERT(PRIVATE_DATA(cc) != 0); 1812 cc += 1 + LINK_SIZE; 1813 break; 1814 1815 case OP_CBRA: 1816 case OP_SCBRA: 1817 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) 1818 private_data_length++; 1819 cc += 1 + LINK_SIZE + IMM2_SIZE; 1820 break; 1821 1822 case OP_CBRAPOS: 1823 case OP_SCBRAPOS: 1824 private_data_length += 2; 1825 cc += 1 + LINK_SIZE + IMM2_SIZE; 1826 break; 1827 1828 case OP_COND: 1829 /* Might be a hidden SCOND. */ 1830 alternative = cc + GET(cc, 1); 1831 if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) 1832 private_data_length++; 1833 cc += 1 + LINK_SIZE; 1834 break; 1835 1836 CASE_ITERATOR_PRIVATE_DATA_1 1837 if (PRIVATE_DATA(cc)) 1838 private_data_length++; 1839 cc += 2; 1840 #ifdef SUPPORT_UNICODE 1841 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 1842 #endif 1843 break; 1844 1845 CASE_ITERATOR_PRIVATE_DATA_2A 1846 if (PRIVATE_DATA(cc)) 1847 private_data_length += 2; 1848 cc += 2; 1849 #ifdef SUPPORT_UNICODE 1850 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 1851 #endif 1852 break; 1853 1854 CASE_ITERATOR_PRIVATE_DATA_2B 1855 if (PRIVATE_DATA(cc)) 1856 private_data_length += 2; 1857 cc += 2 + IMM2_SIZE; 1858 #ifdef SUPPORT_UNICODE 1859 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 1860 #endif 1861 break; 1862 1863 CASE_ITERATOR_TYPE_PRIVATE_DATA_1 1864 if (PRIVATE_DATA(cc)) 1865 private_data_length++; 1866 cc += 1; 1867 break; 1868 1869 CASE_ITERATOR_TYPE_PRIVATE_DATA_2A 1870 if (PRIVATE_DATA(cc)) 1871 private_data_length += 2; 1872 cc += 1; 1873 break; 1874 1875 CASE_ITERATOR_TYPE_PRIVATE_DATA_2B 1876 if (PRIVATE_DATA(cc)) 1877 private_data_length += 2; 1878 cc += 1 + IMM2_SIZE; 1879 break; 1880 1881 case OP_CLASS: 1882 case OP_NCLASS: 1883 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 1884 case OP_XCLASS: 1885 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(PCRE2_UCHAR); 1886 #else 1887 size = 1 + 32 / (int)sizeof(PCRE2_UCHAR); 1888 #endif 1889 if (PRIVATE_DATA(cc)) 1890 private_data_length += get_class_iterator_size(cc + size); 1891 cc += size; 1892 break; 1893 1894 default: 1895 cc = next_opcode(common, cc); 1896 SLJIT_ASSERT(cc != NULL); 1897 break; 1898 } 1899 } 1900 SLJIT_ASSERT(cc == ccend); 1901 return private_data_length; 1902 } 1903 1904 static void copy_private_data(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, 1905 BOOL save, int stackptr, int stacktop, BOOL needs_control_head) 1906 { 1907 DEFINE_COMPILER; 1908 int srcw[2]; 1909 int count, size; 1910 BOOL tmp1next = TRUE; 1911 BOOL tmp1empty = TRUE; 1912 BOOL tmp2empty = TRUE; 1913 PCRE2_SPTR alternative; 1914 enum { 1915 start, 1916 loop, 1917 end 1918 } status; 1919 1920 status = save ? start : loop; 1921 stackptr = STACK(stackptr - 2); 1922 stacktop = STACK(stacktop - 1); 1923 1924 if (!save) 1925 { 1926 stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw); 1927 if (stackptr < stacktop) 1928 { 1929 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr); 1930 stackptr += sizeof(sljit_sw); 1931 tmp1empty = FALSE; 1932 } 1933 if (stackptr < stacktop) 1934 { 1935 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr); 1936 stackptr += sizeof(sljit_sw); 1937 tmp2empty = FALSE; 1938 } 1939 /* The tmp1next must be TRUE in either way. */ 1940 } 1941 1942 do 1943 { 1944 count = 0; 1945 switch(status) 1946 { 1947 case start: 1948 SLJIT_ASSERT(save && common->recursive_head_ptr != 0); 1949 count = 1; 1950 srcw[0] = common->recursive_head_ptr; 1951 if (needs_control_head) 1952 { 1953 SLJIT_ASSERT(common->control_head_ptr != 0); 1954 count = 2; 1955 srcw[1] = common->control_head_ptr; 1956 } 1957 status = loop; 1958 break; 1959 1960 case loop: 1961 if (cc >= ccend) 1962 { 1963 status = end; 1964 break; 1965 } 1966 1967 switch(*cc) 1968 { 1969 case OP_KET: 1970 if (PRIVATE_DATA(cc) != 0) 1971 { 1972 count = 1; 1973 srcw[0] = PRIVATE_DATA(cc); 1974 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0); 1975 cc += PRIVATE_DATA(cc + 1); 1976 } 1977 cc += 1 + LINK_SIZE; 1978 break; 1979 1980 case OP_ASSERT: 1981 case OP_ASSERT_NOT: 1982 case OP_ASSERTBACK: 1983 case OP_ASSERTBACK_NOT: 1984 case OP_ONCE: 1985 case OP_ONCE_NC: 1986 case OP_BRAPOS: 1987 case OP_SBRA: 1988 case OP_SBRAPOS: 1989 case OP_SCOND: 1990 count = 1; 1991 srcw[0] = PRIVATE_DATA(cc); 1992 SLJIT_ASSERT(srcw[0] != 0); 1993 cc += 1 + LINK_SIZE; 1994 break; 1995 1996 case OP_CBRA: 1997 case OP_SCBRA: 1998 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) 1999 { 2000 count = 1; 2001 srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE)); 2002 } 2003 cc += 1 + LINK_SIZE + IMM2_SIZE; 2004 break; 2005 2006 case OP_CBRAPOS: 2007 case OP_SCBRAPOS: 2008 count = 2; 2009 srcw[0] = PRIVATE_DATA(cc); 2010 srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE)); 2011 SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0); 2012 cc += 1 + LINK_SIZE + IMM2_SIZE; 2013 break; 2014 2015 case OP_COND: 2016 /* Might be a hidden SCOND. */ 2017 alternative = cc + GET(cc, 1); 2018 if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) 2019 { 2020 count = 1; 2021 srcw[0] = PRIVATE_DATA(cc); 2022 SLJIT_ASSERT(srcw[0] != 0); 2023 } 2024 cc += 1 + LINK_SIZE; 2025 break; 2026 2027 CASE_ITERATOR_PRIVATE_DATA_1 2028 if (PRIVATE_DATA(cc)) 2029 { 2030 count = 1; 2031 srcw[0] = PRIVATE_DATA(cc); 2032 } 2033 cc += 2; 2034 #ifdef SUPPORT_UNICODE 2035 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 2036 #endif 2037 break; 2038 2039 CASE_ITERATOR_PRIVATE_DATA_2A 2040 if (PRIVATE_DATA(cc)) 2041 { 2042 count = 2; 2043 srcw[0] = PRIVATE_DATA(cc); 2044 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw); 2045 } 2046 cc += 2; 2047 #ifdef SUPPORT_UNICODE 2048 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 2049 #endif 2050 break; 2051 2052 CASE_ITERATOR_PRIVATE_DATA_2B 2053 if (PRIVATE_DATA(cc)) 2054 { 2055 count = 2; 2056 srcw[0] = PRIVATE_DATA(cc); 2057 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw); 2058 } 2059 cc += 2 + IMM2_SIZE; 2060 #ifdef SUPPORT_UNICODE 2061 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); 2062 #endif 2063 break; 2064 2065 CASE_ITERATOR_TYPE_PRIVATE_DATA_1 2066 if (PRIVATE_DATA(cc)) 2067 { 2068 count = 1; 2069 srcw[0] = PRIVATE_DATA(cc); 2070 } 2071 cc += 1; 2072 break; 2073 2074 CASE_ITERATOR_TYPE_PRIVATE_DATA_2A 2075 if (PRIVATE_DATA(cc)) 2076 { 2077 count = 2; 2078 srcw[0] = PRIVATE_DATA(cc); 2079 srcw[1] = srcw[0] + sizeof(sljit_sw); 2080 } 2081 cc += 1; 2082 break; 2083 2084 CASE_ITERATOR_TYPE_PRIVATE_DATA_2B 2085 if (PRIVATE_DATA(cc)) 2086 { 2087 count = 2; 2088 srcw[0] = PRIVATE_DATA(cc); 2089 srcw[1] = srcw[0] + sizeof(sljit_sw); 2090 } 2091 cc += 1 + IMM2_SIZE; 2092 break; 2093 2094 case OP_CLASS: 2095 case OP_NCLASS: 2096 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 2097 case OP_XCLASS: 2098 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(PCRE2_UCHAR); 2099 #else 2100 size = 1 + 32 / (int)sizeof(PCRE2_UCHAR); 2101 #endif 2102 if (PRIVATE_DATA(cc)) 2103 switch(get_class_iterator_size(cc + size)) 2104 { 2105 case 1: 2106 count = 1; 2107 srcw[0] = PRIVATE_DATA(cc); 2108 break; 2109 2110 case 2: 2111 count = 2; 2112 srcw[0] = PRIVATE_DATA(cc); 2113 srcw[1] = srcw[0] + sizeof(sljit_sw); 2114 break; 2115 2116 default: 2117 SLJIT_ASSERT_STOP(); 2118 break; 2119 } 2120 cc += size; 2121 break; 2122 2123 default: 2124 cc = next_opcode(common, cc); 2125 SLJIT_ASSERT(cc != NULL); 2126 break; 2127 } 2128 break; 2129 2130 case end: 2131 SLJIT_ASSERT_STOP(); 2132 break; 2133 } 2134 2135 while (count > 0) 2136 { 2137 count--; 2138 if (save) 2139 { 2140 if (tmp1next) 2141 { 2142 if (!tmp1empty) 2143 { 2144 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0); 2145 stackptr += sizeof(sljit_sw); 2146 } 2147 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]); 2148 tmp1empty = FALSE; 2149 tmp1next = FALSE; 2150 } 2151 else 2152 { 2153 if (!tmp2empty) 2154 { 2155 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0); 2156 stackptr += sizeof(sljit_sw); 2157 } 2158 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]); 2159 tmp2empty = FALSE; 2160 tmp1next = TRUE; 2161 } 2162 } 2163 else 2164 { 2165 if (tmp1next) 2166 { 2167 SLJIT_ASSERT(!tmp1empty); 2168 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0); 2169 tmp1empty = stackptr >= stacktop; 2170 if (!tmp1empty) 2171 { 2172 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr); 2173 stackptr += sizeof(sljit_sw); 2174 } 2175 tmp1next = FALSE; 2176 } 2177 else 2178 { 2179 SLJIT_ASSERT(!tmp2empty); 2180 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0); 2181 tmp2empty = stackptr >= stacktop; 2182 if (!tmp2empty) 2183 { 2184 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr); 2185 stackptr += sizeof(sljit_sw); 2186 } 2187 tmp1next = TRUE; 2188 } 2189 } 2190 } 2191 } 2192 while (status != end); 2193 2194 if (save) 2195 { 2196 if (tmp1next) 2197 { 2198 if (!tmp1empty) 2199 { 2200 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0); 2201 stackptr += sizeof(sljit_sw); 2202 } 2203 if (!tmp2empty) 2204 { 2205 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0); 2206 stackptr += sizeof(sljit_sw); 2207 } 2208 } 2209 else 2210 { 2211 if (!tmp2empty) 2212 { 2213 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0); 2214 stackptr += sizeof(sljit_sw); 2215 } 2216 if (!tmp1empty) 2217 { 2218 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0); 2219 stackptr += sizeof(sljit_sw); 2220 } 2221 } 2222 } 2223 SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty))); 2224 } 2225 2226 static SLJIT_INLINE PCRE2_SPTR set_then_offsets(compiler_common *common, PCRE2_SPTR cc, sljit_u8 *current_offset) 2227 { 2228 PCRE2_SPTR end = bracketend(cc); 2229 BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT; 2230 2231 /* Assert captures then. */ 2232 if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) 2233 current_offset = NULL; 2234 /* Conditional block does not. */ 2235 if (*cc == OP_COND || *cc == OP_SCOND) 2236 has_alternatives = FALSE; 2237 2238 cc = next_opcode(common, cc); 2239 if (has_alternatives) 2240 current_offset = common->then_offsets + (cc - common->start); 2241 2242 while (cc < end) 2243 { 2244 if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND)) 2245 cc = set_then_offsets(common, cc, current_offset); 2246 else 2247 { 2248 if (*cc == OP_ALT && has_alternatives) 2249 current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start); 2250 if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL) 2251 *current_offset = 1; 2252 cc = next_opcode(common, cc); 2253 } 2254 } 2255 2256 return end; 2257 } 2258 2259 #undef CASE_ITERATOR_PRIVATE_DATA_1 2260 #undef CASE_ITERATOR_PRIVATE_DATA_2A 2261 #undef CASE_ITERATOR_PRIVATE_DATA_2B 2262 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1 2263 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A 2264 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B 2265 2266 static SLJIT_INLINE BOOL is_powerof2(unsigned int value) 2267 { 2268 return (value & (value - 1)) == 0; 2269 } 2270 2271 static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label) 2272 { 2273 while (list) 2274 { 2275 /* sljit_set_label is clever enough to do nothing 2276 if either the jump or the label is NULL. */ 2277 SET_LABEL(list->jump, label); 2278 list = list->next; 2279 } 2280 } 2281 2282 static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump) 2283 { 2284 jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list)); 2285 if (list_item) 2286 { 2287 list_item->next = *list; 2288 list_item->jump = jump; 2289 *list = list_item; 2290 } 2291 } 2292 2293 static void add_stub(compiler_common *common, struct sljit_jump *start) 2294 { 2295 DEFINE_COMPILER; 2296 stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list)); 2297 2298 if (list_item) 2299 { 2300 list_item->start = start; 2301 list_item->quit = LABEL(); 2302 list_item->next = common->stubs; 2303 common->stubs = list_item; 2304 } 2305 } 2306 2307 static void flush_stubs(compiler_common *common) 2308 { 2309 DEFINE_COMPILER; 2310 stub_list *list_item = common->stubs; 2311 2312 while (list_item) 2313 { 2314 JUMPHERE(list_item->start); 2315 add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL)); 2316 JUMPTO(SLJIT_JUMP, list_item->quit); 2317 list_item = list_item->next; 2318 } 2319 common->stubs = NULL; 2320 } 2321 2322 static void add_label_addr(compiler_common *common, sljit_uw *update_addr) 2323 { 2324 DEFINE_COMPILER; 2325 label_addr_list *label_addr; 2326 2327 label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list)); 2328 if (label_addr == NULL) 2329 return; 2330 label_addr->label = LABEL(); 2331 label_addr->update_addr = update_addr; 2332 label_addr->next = common->label_addrs; 2333 common->label_addrs = label_addr; 2334 } 2335 2336 static SLJIT_INLINE void count_match(compiler_common *common) 2337 { 2338 DEFINE_COMPILER; 2339 2340 OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1); 2341 add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO)); 2342 } 2343 2344 static SLJIT_INLINE void allocate_stack(compiler_common *common, int size) 2345 { 2346 /* May destroy all locals and registers except TMP2. */ 2347 DEFINE_COMPILER; 2348 2349 SLJIT_ASSERT(size > 0); 2350 OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw)); 2351 #ifdef DESTROY_REGISTERS 2352 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345); 2353 OP1(SLJIT_MOV, TMP3, 0, TMP1, 0); 2354 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); 2355 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0); 2356 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0); 2357 #endif 2358 add_stub(common, CMP(SLJIT_GREATER, STACK_TOP, 0, STACK_LIMIT, 0)); 2359 } 2360 2361 static SLJIT_INLINE void free_stack(compiler_common *common, int size) 2362 { 2363 DEFINE_COMPILER; 2364 2365 SLJIT_ASSERT(size > 0); 2366 OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw)); 2367 } 2368 2369 static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size) 2370 { 2371 DEFINE_COMPILER; 2372 sljit_uw *result; 2373 2374 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) 2375 return NULL; 2376 2377 result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data); 2378 if (SLJIT_UNLIKELY(result == NULL)) 2379 { 2380 sljit_set_compiler_memory_error(compiler); 2381 return NULL; 2382 } 2383 2384 *(void**)result = common->read_only_data_head; 2385 common->read_only_data_head = (void *)result; 2386 return result + 1; 2387 } 2388 2389 static SLJIT_INLINE void reset_ovector(compiler_common *common, int length) 2390 { 2391 DEFINE_COMPILER; 2392 struct sljit_label *loop; 2393 sljit_s32 i; 2394 2395 /* At this point we can freely use all temporary registers. */ 2396 SLJIT_ASSERT(length > 1); 2397 /* TMP1 returns with begin - 1. */ 2398 OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1)); 2399 if (length < 8) 2400 { 2401 for (i = 1; i < length; i++) 2402 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0); 2403 } 2404 else 2405 { 2406 GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START); 2407 OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1); 2408 loop = LABEL(); 2409 OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R0, 0); 2410 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1); 2411 JUMPTO(SLJIT_NOT_ZERO, loop); 2412 } 2413 } 2414 2415 static SLJIT_INLINE void reset_fast_fail(compiler_common *common) 2416 { 2417 DEFINE_COMPILER; 2418 sljit_s32 i; 2419 2420 SLJIT_ASSERT(common->fast_fail_start_ptr < common->fast_fail_end_ptr); 2421 2422 OP2(SLJIT_SUB, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2423 for (i = common->fast_fail_start_ptr; i < common->fast_fail_end_ptr; i += sizeof(sljit_sw)) 2424 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, TMP1, 0); 2425 } 2426 2427 static SLJIT_INLINE void do_reset_match(compiler_common *common, int length) 2428 { 2429 DEFINE_COMPILER; 2430 struct sljit_label *loop; 2431 int i; 2432 2433 SLJIT_ASSERT(length > 1); 2434 /* OVECTOR(1) contains the "string begin - 1" constant. */ 2435 if (length > 2) 2436 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)); 2437 if (length < 8) 2438 { 2439 for (i = 2; i < length; i++) 2440 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0); 2441 } 2442 else 2443 { 2444 GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw)); 2445 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2); 2446 loop = LABEL(); 2447 OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0); 2448 OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1); 2449 JUMPTO(SLJIT_NOT_ZERO, loop); 2450 } 2451 2452 OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0); 2453 if (common->mark_ptr != 0) 2454 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0); 2455 if (common->control_head_ptr != 0) 2456 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0); 2457 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack)); 2458 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr); 2459 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base)); 2460 } 2461 2462 static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, PCRE2_SPTR skip_arg) 2463 { 2464 while (current != NULL) 2465 { 2466 switch (current[-2]) 2467 { 2468 case type_then_trap: 2469 break; 2470 2471 case type_mark: 2472 if (PRIV(strcmp)(skip_arg, (PCRE2_SPTR)current[-3]) == 0) 2473 return current[-4]; 2474 break; 2475 2476 default: 2477 SLJIT_ASSERT_STOP(); 2478 break; 2479 } 2480 SLJIT_ASSERT(current > (sljit_sw*)current[-1]); 2481 current = (sljit_sw*)current[-1]; 2482 } 2483 return -1; 2484 } 2485 2486 static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket) 2487 { 2488 DEFINE_COMPILER; 2489 struct sljit_label *loop; 2490 2491 /* At this point we can freely use all registers. */ 2492 OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)); 2493 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0); 2494 2495 OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0); 2496 OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr); 2497 if (common->mark_ptr != 0) 2498 OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr); 2499 OP1(SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, oveccount)); 2500 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, startchar_ptr), SLJIT_S0, 0); 2501 if (common->mark_ptr != 0) 2502 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0); 2503 OP2(SLJIT_ADD, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, match_data), 2504 SLJIT_IMM, SLJIT_OFFSETOF(pcre2_match_data, ovector) - sizeof(PCRE2_SIZE)); 2505 2506 GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START); 2507 OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin)); 2508 2509 loop = LABEL(); 2510 OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 2511 OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw)); 2512 /* Copy the integer value to the output buffer */ 2513 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 2514 OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT); 2515 #endif 2516 SLJIT_ASSERT(sizeof(PCRE2_SIZE) == 4 || sizeof(PCRE2_SIZE) == 8); 2517 if (sizeof(PCRE2_SIZE) == 4) 2518 OP1(SLJIT_MOVU_U32, SLJIT_MEM1(SLJIT_R2), sizeof(PCRE2_SIZE), SLJIT_S1, 0); 2519 else 2520 OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R2), sizeof(PCRE2_SIZE), SLJIT_S1, 0); 2521 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1); 2522 JUMPTO(SLJIT_NOT_ZERO, loop); 2523 2524 /* Calculate the return value, which is the maximum ovector value. */ 2525 if (topbracket > 1) 2526 { 2527 GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw)); 2528 OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1); 2529 2530 /* OVECTOR(0) is never equal to SLJIT_S2. */ 2531 loop = LABEL(); 2532 OP1(SLJIT_MOVU, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw))); 2533 OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1); 2534 CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop); 2535 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0); 2536 } 2537 else 2538 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1); 2539 } 2540 2541 static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit) 2542 { 2543 DEFINE_COMPILER; 2544 sljit_s32 mov_opcode; 2545 2546 SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2); 2547 SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0 2548 && (common->mode == PCRE2_JIT_PARTIAL_SOFT ? common->hit_start != 0 : common->hit_start == 0)); 2549 2550 OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0); 2551 OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), 2552 common->mode == PCRE2_JIT_PARTIAL_SOFT ? common->hit_start : common->start_ptr); 2553 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE2_ERROR_PARTIAL); 2554 2555 /* Store match begin and end. */ 2556 OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin)); 2557 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, startchar_ptr), SLJIT_R2, 0); 2558 OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, match_data)); 2559 2560 mov_opcode = (sizeof(PCRE2_SIZE) == 4) ? SLJIT_MOV_U32 : SLJIT_MOV; 2561 2562 OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0); 2563 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 2564 OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT); 2565 #endif 2566 OP1(mov_opcode, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(pcre2_match_data, ovector), SLJIT_R2, 0); 2567 2568 OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_S0, 0); 2569 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 2570 OP2(SLJIT_ASHR, STR_END, 0, STR_END, 0, SLJIT_IMM, UCHAR_SHIFT); 2571 #endif 2572 OP1(mov_opcode, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(pcre2_match_data, ovector) + sizeof(PCRE2_SIZE), STR_END, 0); 2573 2574 JUMPTO(SLJIT_JUMP, quit); 2575 } 2576 2577 static SLJIT_INLINE void check_start_used_ptr(compiler_common *common) 2578 { 2579 /* May destroy TMP1. */ 2580 DEFINE_COMPILER; 2581 struct sljit_jump *jump; 2582 2583 if (common->mode == PCRE2_JIT_PARTIAL_SOFT) 2584 { 2585 /* The value of -1 must be kept for start_used_ptr! */ 2586 OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1); 2587 /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting 2588 is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */ 2589 jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0); 2590 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0); 2591 JUMPHERE(jump); 2592 } 2593 else if (common->mode == PCRE2_JIT_PARTIAL_HARD) 2594 { 2595 jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0); 2596 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0); 2597 JUMPHERE(jump); 2598 } 2599 } 2600 2601 static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, PCRE2_SPTR cc) 2602 { 2603 /* Detects if the character has an othercase. */ 2604 unsigned int c; 2605 2606 #ifdef SUPPORT_UNICODE 2607 if (common->utf) 2608 { 2609 GETCHAR(c, cc); 2610 if (c > 127) 2611 { 2612 return c != UCD_OTHERCASE(c); 2613 } 2614 #if PCRE2_CODE_UNIT_WIDTH != 8 2615 return common->fcc[c] != c; 2616 #endif 2617 } 2618 else 2619 #endif 2620 c = *cc; 2621 return MAX_255(c) ? common->fcc[c] != c : FALSE; 2622 } 2623 2624 static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c) 2625 { 2626 /* Returns with the othercase. */ 2627 #ifdef SUPPORT_UNICODE 2628 if (common->utf && c > 127) 2629 { 2630 return UCD_OTHERCASE(c); 2631 } 2632 #endif 2633 return TABLE_GET(c, common->fcc, c); 2634 } 2635 2636 static unsigned int char_get_othercase_bit(compiler_common *common, PCRE2_SPTR cc) 2637 { 2638 /* Detects if the character and its othercase has only 1 bit difference. */ 2639 unsigned int c, oc, bit; 2640 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 2641 int n; 2642 #endif 2643 2644 #ifdef SUPPORT_UNICODE 2645 if (common->utf) 2646 { 2647 GETCHAR(c, cc); 2648 if (c <= 127) 2649 oc = common->fcc[c]; 2650 else 2651 { 2652 oc = UCD_OTHERCASE(c); 2653 } 2654 } 2655 else 2656 { 2657 c = *cc; 2658 oc = TABLE_GET(c, common->fcc, c); 2659 } 2660 #else 2661 c = *cc; 2662 oc = TABLE_GET(c, common->fcc, c); 2663 #endif 2664 2665 SLJIT_ASSERT(c != oc); 2666 2667 bit = c ^ oc; 2668 /* Optimized for English alphabet. */ 2669 if (c <= 127 && bit == 0x20) 2670 return (0 << 8) | 0x20; 2671 2672 /* Since c != oc, they must have at least 1 bit difference. */ 2673 if (!is_powerof2(bit)) 2674 return 0; 2675 2676 #if PCRE2_CODE_UNIT_WIDTH == 8 2677 2678 #ifdef SUPPORT_UNICODE 2679 if (common->utf && c > 127) 2680 { 2681 n = GET_EXTRALEN(*cc); 2682 while ((bit & 0x3f) == 0) 2683 { 2684 n--; 2685 bit >>= 6; 2686 } 2687 return (n << 8) | bit; 2688 } 2689 #endif /* SUPPORT_UNICODE */ 2690 return (0 << 8) | bit; 2691 2692 #elif PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 2693 2694 #ifdef SUPPORT_UNICODE 2695 if (common->utf && c > 65535) 2696 { 2697 if (bit >= (1 << 10)) 2698 bit >>= 10; 2699 else 2700 return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8)); 2701 } 2702 #endif /* SUPPORT_UNICODE */ 2703 return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8)); 2704 2705 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16|32] */ 2706 } 2707 2708 static void check_partial(compiler_common *common, BOOL force) 2709 { 2710 /* Checks whether a partial matching is occurred. Does not modify registers. */ 2711 DEFINE_COMPILER; 2712 struct sljit_jump *jump = NULL; 2713 2714 SLJIT_ASSERT(!force || common->mode != PCRE2_JIT_COMPLETE); 2715 2716 if (common->mode == PCRE2_JIT_COMPLETE) 2717 return; 2718 2719 if (!force) 2720 jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0); 2721 else if (common->mode == PCRE2_JIT_PARTIAL_SOFT) 2722 jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1); 2723 2724 if (common->mode == PCRE2_JIT_PARTIAL_SOFT) 2725 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0); 2726 else 2727 { 2728 if (common->partialmatchlabel != NULL) 2729 JUMPTO(SLJIT_JUMP, common->partialmatchlabel); 2730 else 2731 add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP)); 2732 } 2733 2734 if (jump != NULL) 2735 JUMPHERE(jump); 2736 } 2737 2738 static void check_str_end(compiler_common *common, jump_list **end_reached) 2739 { 2740 /* Does not affect registers. Usually used in a tight spot. */ 2741 DEFINE_COMPILER; 2742 struct sljit_jump *jump; 2743 2744 if (common->mode == PCRE2_JIT_COMPLETE) 2745 { 2746 add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0)); 2747 return; 2748 } 2749 2750 jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0); 2751 if (common->mode == PCRE2_JIT_PARTIAL_SOFT) 2752 { 2753 add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0)); 2754 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0); 2755 add_jump(compiler, end_reached, JUMP(SLJIT_JUMP)); 2756 } 2757 else 2758 { 2759 add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0)); 2760 if (common->partialmatchlabel != NULL) 2761 JUMPTO(SLJIT_JUMP, common->partialmatchlabel); 2762 else 2763 add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP)); 2764 } 2765 JUMPHERE(jump); 2766 } 2767 2768 static void detect_partial_match(compiler_common *common, jump_list **backtracks) 2769 { 2770 DEFINE_COMPILER; 2771 struct sljit_jump *jump; 2772 2773 if (common->mode == PCRE2_JIT_COMPLETE) 2774 { 2775 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0)); 2776 return; 2777 } 2778 2779 /* Partial matching mode. */ 2780 jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0); 2781 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0)); 2782 if (common->mode == PCRE2_JIT_PARTIAL_SOFT) 2783 { 2784 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0); 2785 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 2786 } 2787 else 2788 { 2789 if (common->partialmatchlabel != NULL) 2790 JUMPTO(SLJIT_JUMP, common->partialmatchlabel); 2791 else 2792 add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP)); 2793 } 2794 JUMPHERE(jump); 2795 } 2796 2797 static void peek_char(compiler_common *common, sljit_u32 max) 2798 { 2799 /* Reads the character into TMP1, keeps STR_PTR. 2800 Does not check STR_END. TMP2 Destroyed. */ 2801 DEFINE_COMPILER; 2802 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 2803 struct sljit_jump *jump; 2804 #endif 2805 2806 SLJIT_UNUSED_ARG(max); 2807 2808 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 2809 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 2810 if (common->utf) 2811 { 2812 if (max < 128) return; 2813 2814 jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0); 2815 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2816 add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL)); 2817 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 2818 JUMPHERE(jump); 2819 } 2820 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 */ 2821 2822 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 16 2823 if (common->utf) 2824 { 2825 if (max < 0xd800) return; 2826 2827 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800); 2828 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1); 2829 /* TMP2 contains the high surrogate. */ 2830 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2831 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40); 2832 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10); 2833 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff); 2834 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2835 JUMPHERE(jump); 2836 } 2837 #endif 2838 } 2839 2840 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 2841 2842 static BOOL is_char7_bitset(const sljit_u8 *bitset, BOOL nclass) 2843 { 2844 /* Tells whether the character codes below 128 are enough 2845 to determine a match. */ 2846 const sljit_u8 value = nclass ? 0xff : 0; 2847 const sljit_u8 *end = bitset + 32; 2848 2849 bitset += 16; 2850 do 2851 { 2852 if (*bitset++ != value) 2853 return FALSE; 2854 } 2855 while (bitset < end); 2856 return TRUE; 2857 } 2858 2859 static void read_char7_type(compiler_common *common, BOOL full_read) 2860 { 2861 /* Reads the precise character type of a character into TMP1, if the character 2862 is less than 128. Otherwise it returns with zero. Does not check STR_END. The 2863 full_read argument tells whether characters above max are accepted or not. */ 2864 DEFINE_COMPILER; 2865 struct sljit_jump *jump; 2866 2867 SLJIT_ASSERT(common->utf); 2868 2869 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0); 2870 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2871 2872 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); 2873 2874 if (full_read) 2875 { 2876 jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0); 2877 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0); 2878 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 2879 JUMPHERE(jump); 2880 } 2881 } 2882 2883 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 */ 2884 2885 static void read_char_range(compiler_common *common, sljit_u32 min, sljit_u32 max, BOOL update_str_ptr) 2886 { 2887 /* Reads the precise value of a character into TMP1, if the character is 2888 between min and max (c >= min && c <= max). Otherwise it returns with a value 2889 outside the range. Does not check STR_END. */ 2890 DEFINE_COMPILER; 2891 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 2892 struct sljit_jump *jump; 2893 #endif 2894 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 2895 struct sljit_jump *jump2; 2896 #endif 2897 2898 SLJIT_UNUSED_ARG(update_str_ptr); 2899 SLJIT_UNUSED_ARG(min); 2900 SLJIT_UNUSED_ARG(max); 2901 SLJIT_ASSERT(min <= max); 2902 2903 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2904 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2905 2906 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 2907 if (common->utf) 2908 { 2909 if (max < 128 && !update_str_ptr) return; 2910 2911 jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0); 2912 if (min >= 0x10000) 2913 { 2914 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0); 2915 if (update_str_ptr) 2916 OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 2917 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2918 jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7); 2919 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); 2920 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 2921 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2922 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 2923 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 2924 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 2925 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2926 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2)); 2927 if (!update_str_ptr) 2928 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3)); 2929 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 2930 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 2931 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2932 JUMPHERE(jump2); 2933 if (update_str_ptr) 2934 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0); 2935 } 2936 else if (min >= 0x800 && max <= 0xffff) 2937 { 2938 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0); 2939 if (update_str_ptr) 2940 OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 2941 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2942 jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf); 2943 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); 2944 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 2945 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2946 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 2947 if (!update_str_ptr) 2948 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 2949 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 2950 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 2951 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2952 JUMPHERE(jump2); 2953 if (update_str_ptr) 2954 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0); 2955 } 2956 else if (max >= 0x800) 2957 add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL)); 2958 else if (max < 128) 2959 { 2960 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 2961 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 2962 } 2963 else 2964 { 2965 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2966 if (!update_str_ptr) 2967 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2968 else 2969 OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 2970 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 2971 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 2972 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 2973 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2974 if (update_str_ptr) 2975 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0); 2976 } 2977 JUMPHERE(jump); 2978 } 2979 #endif 2980 2981 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 16 2982 if (common->utf) 2983 { 2984 if (max >= 0x10000) 2985 { 2986 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800); 2987 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1); 2988 /* TMP2 contains the high surrogate. */ 2989 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 2990 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40); 2991 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10); 2992 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 2993 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff); 2994 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 2995 JUMPHERE(jump); 2996 return; 2997 } 2998 2999 if (max < 0xd800 && !update_str_ptr) return; 3000 3001 /* Skip low surrogate if necessary. */ 3002 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800); 3003 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1); 3004 if (update_str_ptr) 3005 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3006 if (max >= 0xd800) 3007 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000); 3008 JUMPHERE(jump); 3009 } 3010 #endif 3011 } 3012 3013 static SLJIT_INLINE void read_char(compiler_common *common) 3014 { 3015 read_char_range(common, 0, READ_CHAR_MAX, TRUE); 3016 } 3017 3018 static void read_char8_type(compiler_common *common, BOOL update_str_ptr) 3019 { 3020 /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */ 3021 DEFINE_COMPILER; 3022 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 3023 struct sljit_jump *jump; 3024 #endif 3025 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3026 struct sljit_jump *jump2; 3027 #endif 3028 3029 SLJIT_UNUSED_ARG(update_str_ptr); 3030 3031 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0); 3032 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3033 3034 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3035 if (common->utf) 3036 { 3037 /* This can be an extra read in some situations, but hopefully 3038 it is needed in most cases. */ 3039 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); 3040 jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0); 3041 if (!update_str_ptr) 3042 { 3043 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 3044 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3045 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3046 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); 3047 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 3048 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0); 3049 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); 3050 jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255); 3051 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); 3052 JUMPHERE(jump2); 3053 } 3054 else 3055 add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL)); 3056 JUMPHERE(jump); 3057 return; 3058 } 3059 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 */ 3060 3061 #if PCRE2_CODE_UNIT_WIDTH != 8 3062 /* The ctypes array contains only 256 values. */ 3063 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); 3064 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255); 3065 #endif 3066 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); 3067 #if PCRE2_CODE_UNIT_WIDTH != 8 3068 JUMPHERE(jump); 3069 #endif 3070 3071 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 16 3072 if (common->utf && update_str_ptr) 3073 { 3074 /* Skip low surrogate if necessary. */ 3075 OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800); 3076 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1); 3077 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3078 JUMPHERE(jump); 3079 } 3080 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 16 */ 3081 } 3082 3083 static void skip_char_back(compiler_common *common) 3084 { 3085 /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */ 3086 DEFINE_COMPILER; 3087 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3088 #if PCRE2_CODE_UNIT_WIDTH == 8 3089 struct sljit_label *label; 3090 3091 if (common->utf) 3092 { 3093 label = LABEL(); 3094 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1)); 3095 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3096 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0); 3097 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label); 3098 return; 3099 } 3100 #elif PCRE2_CODE_UNIT_WIDTH == 16 3101 if (common->utf) 3102 { 3103 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1)); 3104 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3105 /* Skip low surrogate if necessary. */ 3106 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 3107 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00); 3108 OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 3109 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1); 3110 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 3111 return; 3112 } 3113 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16] */ 3114 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 */ 3115 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3116 } 3117 3118 static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch) 3119 { 3120 /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */ 3121 DEFINE_COMPILER; 3122 struct sljit_jump *jump; 3123 3124 if (nltype == NLTYPE_ANY) 3125 { 3126 add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL)); 3127 add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO)); 3128 } 3129 else if (nltype == NLTYPE_ANYCRLF) 3130 { 3131 if (jumpifmatch) 3132 { 3133 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR)); 3134 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL)); 3135 } 3136 else 3137 { 3138 jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR); 3139 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL)); 3140 JUMPHERE(jump); 3141 } 3142 } 3143 else 3144 { 3145 SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256); 3146 add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline)); 3147 } 3148 } 3149 3150 #ifdef SUPPORT_UNICODE 3151 3152 #if PCRE2_CODE_UNIT_WIDTH == 8 3153 static void do_utfreadchar(compiler_common *common) 3154 { 3155 /* Fast decoding a UTF-8 character. TMP1 contains the first byte 3156 of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */ 3157 DEFINE_COMPILER; 3158 struct sljit_jump *jump; 3159 3160 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 3161 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 3162 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 3163 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 3164 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3165 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 3166 3167 /* Searching for the first zero. */ 3168 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800); 3169 jump = JUMP(SLJIT_NOT_ZERO); 3170 /* Two byte sequence. */ 3171 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3172 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2)); 3173 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3174 3175 JUMPHERE(jump); 3176 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 3177 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800); 3178 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 3179 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3180 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 3181 3182 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000); 3183 jump = JUMP(SLJIT_NOT_ZERO); 3184 /* Three byte sequence. */ 3185 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 3186 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3)); 3187 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3188 3189 /* Four byte sequence. */ 3190 JUMPHERE(jump); 3191 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2)); 3192 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000); 3193 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 3194 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3)); 3195 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3196 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 3197 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4)); 3198 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3199 } 3200 3201 static void do_utfreadchar16(compiler_common *common) 3202 { 3203 /* Fast decoding a UTF-8 character. TMP1 contains the first byte 3204 of the character (>= 0xc0). Return value in TMP1. */ 3205 DEFINE_COMPILER; 3206 struct sljit_jump *jump; 3207 3208 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 3209 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 3210 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 3211 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 3212 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3213 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 3214 3215 /* Searching for the first zero. */ 3216 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800); 3217 jump = JUMP(SLJIT_NOT_ZERO); 3218 /* Two byte sequence. */ 3219 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3220 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3221 3222 JUMPHERE(jump); 3223 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400); 3224 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 3225 /* This code runs only in 8 bit mode. No need to shift the value. */ 3226 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 3227 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 3228 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800); 3229 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); 3230 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); 3231 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 3232 /* Three byte sequence. */ 3233 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 3234 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3235 } 3236 3237 static void do_utfreadtype8(compiler_common *common) 3238 { 3239 /* Fast decoding a UTF-8 character type. TMP2 contains the first byte 3240 of the character (>= 0xc0). Return value in TMP1. */ 3241 DEFINE_COMPILER; 3242 struct sljit_jump *jump; 3243 struct sljit_jump *compare; 3244 3245 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 3246 3247 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20); 3248 jump = JUMP(SLJIT_NOT_ZERO); 3249 /* Two byte sequence. */ 3250 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 3251 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3252 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f); 3253 /* The upper 5 bits are known at this point. */ 3254 compare = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x3); 3255 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); 3256 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); 3257 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0); 3258 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); 3259 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3260 3261 JUMPHERE(compare); 3262 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); 3263 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3264 3265 /* We only have types for characters less than 256. */ 3266 JUMPHERE(jump); 3267 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0); 3268 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); 3269 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 3270 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3271 } 3272 3273 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 3274 3275 /* UCD_BLOCK_SIZE must be 128 (see the assert below). */ 3276 #define UCD_BLOCK_MASK 127 3277 #define UCD_BLOCK_SHIFT 7 3278 3279 static void do_getucd(compiler_common *common) 3280 { 3281 /* Search the UCD record for the character comes in TMP1. 3282 Returns chartype in TMP1 and UCD offset in TMP2. */ 3283 DEFINE_COMPILER; 3284 3285 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8); 3286 3287 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 3288 OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT); 3289 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1)); 3290 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK); 3291 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT); 3292 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0); 3293 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2)); 3294 OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1); 3295 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype)); 3296 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3); 3297 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 3298 } 3299 3300 #endif /* SUPPORT_UNICODE */ 3301 3302 static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, sljit_u32 overall_options) 3303 { 3304 DEFINE_COMPILER; 3305 struct sljit_label *mainloop; 3306 struct sljit_label *newlinelabel = NULL; 3307 struct sljit_jump *start; 3308 struct sljit_jump *end = NULL; 3309 struct sljit_jump *end2 = NULL; 3310 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3311 struct sljit_jump *singlechar; 3312 #endif 3313 jump_list *newline = NULL; 3314 BOOL newlinecheck = FALSE; 3315 BOOL readuchar = FALSE; 3316 3317 if (!(hascrorlf || (overall_options & PCRE2_FIRSTLINE) != 0) 3318 && (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF || common->newline > 255)) 3319 newlinecheck = TRUE; 3320 3321 SLJIT_ASSERT(common->forced_quit_label == NULL); 3322 3323 if ((overall_options & PCRE2_FIRSTLINE) != 0) 3324 { 3325 /* Search for the end of the first line. */ 3326 SLJIT_ASSERT(common->match_end_ptr != 0); 3327 OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0); 3328 3329 if (common->nltype == NLTYPE_FIXED && common->newline > 255) 3330 { 3331 mainloop = LABEL(); 3332 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3333 end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 3334 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1)); 3335 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 3336 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop); 3337 CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop); 3338 JUMPHERE(end); 3339 OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3340 } 3341 else 3342 { 3343 end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 3344 mainloop = LABEL(); 3345 /* Continual stores does not cause data dependency. */ 3346 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0); 3347 read_char_range(common, common->nlmin, common->nlmax, TRUE); 3348 check_newlinechar(common, common->nltype, &newline, TRUE); 3349 CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop); 3350 JUMPHERE(end); 3351 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0); 3352 set_jumps(newline, LABEL()); 3353 } 3354 3355 OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0); 3356 } 3357 else if ((overall_options & PCRE2_USE_OFFSET_LIMIT) != 0) 3358 { 3359 /* Check whether offset limit is set and valid. */ 3360 SLJIT_ASSERT(common->match_end_ptr != 0); 3361 3362 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 3363 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, offset_limit)); 3364 OP1(SLJIT_MOV, TMP2, 0, STR_END, 0); 3365 end = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (sljit_sw) PCRE2_UNSET); 3366 OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0); 3367 #if PCRE2_CODE_UNIT_WIDTH == 16 3368 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1); 3369 #elif PCRE2_CODE_UNIT_WIDTH == 32 3370 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 2); 3371 #endif 3372 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin)); 3373 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0); 3374 end2 = CMP(SLJIT_LESS_EQUAL, TMP2, 0, STR_END, 0); 3375 OP1(SLJIT_MOV, TMP2, 0, STR_END, 0); 3376 JUMPHERE(end2); 3377 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE2_ERROR_NOMATCH); 3378 add_jump(compiler, &common->forced_quit, CMP(SLJIT_LESS, TMP2, 0, STR_PTR, 0)); 3379 JUMPHERE(end); 3380 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, TMP2, 0); 3381 } 3382 3383 start = JUMP(SLJIT_JUMP); 3384 3385 if (newlinecheck) 3386 { 3387 newlinelabel = LABEL(); 3388 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3389 end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 3390 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 3391 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff); 3392 OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 3393 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 3394 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT); 3395 #endif 3396 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 3397 end2 = JUMP(SLJIT_JUMP); 3398 } 3399 3400 mainloop = LABEL(); 3401 3402 /* Increasing the STR_PTR here requires one less jump in the most common case. */ 3403 #ifdef SUPPORT_UNICODE 3404 if (common->utf) readuchar = TRUE; 3405 #endif 3406 if (newlinecheck) readuchar = TRUE; 3407 3408 if (readuchar) 3409 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 3410 3411 if (newlinecheck) 3412 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel); 3413 3414 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 3415 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3416 #if PCRE2_CODE_UNIT_WIDTH == 8 3417 if (common->utf) 3418 { 3419 singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0); 3420 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 3421 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 3422 JUMPHERE(singlechar); 3423 } 3424 #elif PCRE2_CODE_UNIT_WIDTH == 16 3425 if (common->utf) 3426 { 3427 singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800); 3428 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 3429 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800); 3430 OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 3431 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1); 3432 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 3433 JUMPHERE(singlechar); 3434 } 3435 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16] */ 3436 #endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 */ 3437 JUMPHERE(start); 3438 3439 if (newlinecheck) 3440 { 3441 JUMPHERE(end); 3442 JUMPHERE(end2); 3443 } 3444 3445 return mainloop; 3446 } 3447 3448 #define MAX_N_CHARS 16 3449 #define MAX_DIFF_CHARS 6 3450 3451 static SLJIT_INLINE void add_prefix_char(PCRE2_UCHAR chr, PCRE2_UCHAR *chars) 3452 { 3453 PCRE2_UCHAR i, len; 3454 3455 len = chars[0]; 3456 if (len == 255) 3457 return; 3458 3459 if (len == 0) 3460 { 3461 chars[0] = 1; 3462 chars[1] = chr; 3463 return; 3464 } 3465 3466 for (i = len; i > 0; i--) 3467 if (chars[i] == chr) 3468 return; 3469 3470 if (len >= MAX_DIFF_CHARS - 1) 3471 { 3472 chars[0] = 255; 3473 return; 3474 } 3475 3476 len++; 3477 chars[len] = chr; 3478 chars[0] = len; 3479 } 3480 3481 static int scan_prefix(compiler_common *common, PCRE2_SPTR cc, PCRE2_UCHAR *chars, int max_chars, sljit_u32 *rec_count) 3482 { 3483 /* Recursive function, which scans prefix literals. */ 3484 BOOL last, any, class, caseless; 3485 int len, repeat, len_save, consumed = 0; 3486 sljit_u32 chr; /* Any unicode character. */ 3487 sljit_u8 *bytes, *bytes_end, byte; 3488 PCRE2_SPTR alternative, cc_save, oc; 3489 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3490 PCRE2_UCHAR othercase[8]; 3491 #elif defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 16 3492 PCRE2_UCHAR othercase[2]; 3493 #else 3494 PCRE2_UCHAR othercase[1]; 3495 #endif 3496 3497 repeat = 1; 3498 while (TRUE) 3499 { 3500 if (*rec_count == 0) 3501 return 0; 3502 (*rec_count)--; 3503 3504 last = TRUE; 3505 any = FALSE; 3506 class = FALSE; 3507 caseless = FALSE; 3508 3509 switch (*cc) 3510 { 3511 case OP_CHARI: 3512 caseless = TRUE; 3513 case OP_CHAR: 3514 last = FALSE; 3515 cc++; 3516 break; 3517 3518 case OP_SOD: 3519 case OP_SOM: 3520 case OP_SET_SOM: 3521 case OP_NOT_WORD_BOUNDARY: 3522 case OP_WORD_BOUNDARY: 3523 case OP_EODN: 3524 case OP_EOD: 3525 case OP_CIRC: 3526 case OP_CIRCM: 3527 case OP_DOLL: 3528 case OP_DOLLM: 3529 /* Zero width assertions. */ 3530 cc++; 3531 continue; 3532 3533 case OP_ASSERT: 3534 case OP_ASSERT_NOT: 3535 case OP_ASSERTBACK: 3536 case OP_ASSERTBACK_NOT: 3537 cc = bracketend(cc); 3538 continue; 3539 3540 case OP_PLUSI: 3541 case OP_MINPLUSI: 3542 case OP_POSPLUSI: 3543 caseless = TRUE; 3544 case OP_PLUS: 3545 case OP_MINPLUS: 3546 case OP_POSPLUS: 3547 cc++; 3548 break; 3549 3550 case OP_EXACTI: 3551 caseless = TRUE; 3552 case OP_EXACT: 3553 repeat = GET2(cc, 1); 3554 last = FALSE; 3555 cc += 1 + IMM2_SIZE; 3556 break; 3557 3558 case OP_QUERYI: 3559 case OP_MINQUERYI: 3560 case OP_POSQUERYI: 3561 caseless = TRUE; 3562 case OP_QUERY: 3563 case OP_MINQUERY: 3564 case OP_POSQUERY: 3565 len = 1; 3566 cc++; 3567 #ifdef SUPPORT_UNICODE 3568 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc); 3569 #endif 3570 max_chars = scan_prefix(common, cc + len, chars, max_chars, rec_count); 3571 if (max_chars == 0) 3572 return consumed; 3573 last = FALSE; 3574 break; 3575 3576 case OP_KET: 3577 cc += 1 + LINK_SIZE; 3578 continue; 3579 3580 case OP_ALT: 3581 cc += GET(cc, 1); 3582 continue; 3583 3584 case OP_ONCE: 3585 case OP_ONCE_NC: 3586 case OP_BRA: 3587 case OP_BRAPOS: 3588 case OP_CBRA: 3589 case OP_CBRAPOS: 3590 alternative = cc + GET(cc, 1); 3591 while (*alternative == OP_ALT) 3592 { 3593 max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars, rec_count); 3594 if (max_chars == 0) 3595 return consumed; 3596 alternative += GET(alternative, 1); 3597 } 3598 3599 if (*cc == OP_CBRA || *cc == OP_CBRAPOS) 3600 cc += IMM2_SIZE; 3601 cc += 1 + LINK_SIZE; 3602 continue; 3603 3604 case OP_CLASS: 3605 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3606 if (common->utf && !is_char7_bitset((const sljit_u8 *)(cc + 1), FALSE)) 3607 return consumed; 3608 #endif 3609 class = TRUE; 3610 break; 3611 3612 case OP_NCLASS: 3613 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3614 if (common->utf) return consumed; 3615 #endif 3616 class = TRUE; 3617 break; 3618 3619 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 3620 case OP_XCLASS: 3621 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3622 if (common->utf) return consumed; 3623 #endif 3624 any = TRUE; 3625 cc += GET(cc, 1); 3626 break; 3627 #endif 3628 3629 case OP_DIGIT: 3630 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3631 if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE)) 3632 return consumed; 3633 #endif 3634 any = TRUE; 3635 cc++; 3636 break; 3637 3638 case OP_WHITESPACE: 3639 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3640 if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE)) 3641 return consumed; 3642 #endif 3643 any = TRUE; 3644 cc++; 3645 break; 3646 3647 case OP_WORDCHAR: 3648 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 3649 if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE)) 3650 return consumed; 3651 #endif 3652 any = TRUE; 3653 cc++; 3654 break; 3655 3656 case OP_NOT: 3657 case OP_NOTI: 3658 cc++; 3659 /* Fall through. */ 3660 case OP_NOT_DIGIT: 3661 case OP_NOT_WHITESPACE: 3662 case OP_NOT_WORDCHAR: 3663 case OP_ANY: 3664 case OP_ALLANY: 3665 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3666 if (common->utf) return consumed; 3667 #endif 3668 any = TRUE; 3669 cc++; 3670 break; 3671 3672 #ifdef SUPPORT_UNICODE 3673 case OP_NOTPROP: 3674 case OP_PROP: 3675 #if PCRE2_CODE_UNIT_WIDTH != 32 3676 if (common->utf) return consumed; 3677 #endif 3678 any = TRUE; 3679 cc += 1 + 2; 3680 break; 3681 #endif 3682 3683 case OP_TYPEEXACT: 3684 repeat = GET2(cc, 1); 3685 cc += 1 + IMM2_SIZE; 3686 continue; 3687 3688 case OP_NOTEXACT: 3689 case OP_NOTEXACTI: 3690 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3691 if (common->utf) return consumed; 3692 #endif 3693 any = TRUE; 3694 repeat = GET2(cc, 1); 3695 cc += 1 + IMM2_SIZE + 1; 3696 break; 3697 3698 default: 3699 return consumed; 3700 } 3701 3702 if (any) 3703 { 3704 do 3705 { 3706 chars[0] = 255; 3707 3708 consumed++; 3709 if (--max_chars == 0) 3710 return consumed; 3711 chars += MAX_DIFF_CHARS; 3712 } 3713 while (--repeat > 0); 3714 3715 repeat = 1; 3716 continue; 3717 } 3718 3719 if (class) 3720 { 3721 bytes = (sljit_u8*) (cc + 1); 3722 cc += 1 + 32 / sizeof(PCRE2_UCHAR); 3723 3724 switch (*cc) 3725 { 3726 case OP_CRSTAR: 3727 case OP_CRMINSTAR: 3728 case OP_CRPOSSTAR: 3729 case OP_CRQUERY: 3730 case OP_CRMINQUERY: 3731 case OP_CRPOSQUERY: 3732 max_chars = scan_prefix(common, cc + 1, chars, max_chars, rec_count); 3733 if (max_chars == 0) 3734 return consumed; 3735 break; 3736 3737 default: 3738 case OP_CRPLUS: 3739 case OP_CRMINPLUS: 3740 case OP_CRPOSPLUS: 3741 break; 3742 3743 case OP_CRRANGE: 3744 case OP_CRMINRANGE: 3745 case OP_CRPOSRANGE: 3746 repeat = GET2(cc, 1); 3747 if (repeat <= 0) 3748 return consumed; 3749 break; 3750 } 3751 3752 do 3753 { 3754 if (bytes[31] & 0x80) 3755 chars[0] = 255; 3756 else if (chars[0] != 255) 3757 { 3758 bytes_end = bytes + 32; 3759 chr = 0; 3760 do 3761 { 3762 byte = *bytes++; 3763 SLJIT_ASSERT((chr & 0x7) == 0); 3764 if (byte == 0) 3765 chr += 8; 3766 else 3767 { 3768 do 3769 { 3770 if ((byte & 0x1) != 0) 3771 add_prefix_char(chr, chars); 3772 byte >>= 1; 3773 chr++; 3774 } 3775 while (byte != 0); 3776 chr = (chr + 7) & ~7; 3777 } 3778 } 3779 while (chars[0] != 255 && bytes < bytes_end); 3780 bytes = bytes_end - 32; 3781 } 3782 3783 consumed++; 3784 if (--max_chars == 0) 3785 return consumed; 3786 chars += MAX_DIFF_CHARS; 3787 } 3788 while (--repeat > 0); 3789 3790 switch (*cc) 3791 { 3792 case OP_CRSTAR: 3793 case OP_CRMINSTAR: 3794 case OP_CRPOSSTAR: 3795 return consumed; 3796 3797 case OP_CRQUERY: 3798 case OP_CRMINQUERY: 3799 case OP_CRPOSQUERY: 3800 cc++; 3801 break; 3802 3803 case OP_CRRANGE: 3804 case OP_CRMINRANGE: 3805 case OP_CRPOSRANGE: 3806 if (GET2(cc, 1) != GET2(cc, 1 + IMM2_SIZE)) 3807 return consumed; 3808 cc += 1 + 2 * IMM2_SIZE; 3809 break; 3810 } 3811 3812 repeat = 1; 3813 continue; 3814 } 3815 3816 len = 1; 3817 #ifdef SUPPORT_UNICODE 3818 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc); 3819 #endif 3820 3821 if (caseless && char_has_othercase(common, cc)) 3822 { 3823 #ifdef SUPPORT_UNICODE 3824 if (common->utf) 3825 { 3826 GETCHAR(chr, cc); 3827 if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len) 3828 return consumed; 3829 } 3830 else 3831 #endif 3832 { 3833 chr = *cc; 3834 othercase[0] = TABLE_GET(chr, common->fcc, chr); 3835 } 3836 } 3837 else 3838 { 3839 caseless = FALSE; 3840 othercase[0] = 0; /* Stops compiler warning - PH */ 3841 } 3842 3843 len_save = len; 3844 cc_save = cc; 3845 while (TRUE) 3846 { 3847 oc = othercase; 3848 do 3849 { 3850 chr = *cc; 3851 add_prefix_char(*cc, chars); 3852 3853 if (caseless) 3854 add_prefix_char(*oc, chars); 3855 3856 len--; 3857 consumed++; 3858 if (--max_chars == 0) 3859 return consumed; 3860 chars += MAX_DIFF_CHARS; 3861 cc++; 3862 oc++; 3863 } 3864 while (len > 0); 3865 3866 if (--repeat == 0) 3867 break; 3868 3869 len = len_save; 3870 cc = cc_save; 3871 } 3872 3873 repeat = 1; 3874 if (last) 3875 return consumed; 3876 } 3877 } 3878 3879 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 3880 3881 static sljit_s32 character_to_int32(PCRE2_UCHAR chr) 3882 { 3883 sljit_s32 value = (sljit_s32)chr; 3884 #if PCRE2_CODE_UNIT_WIDTH == 8 3885 #define SSE2_COMPARE_TYPE_INDEX 0 3886 return (value << 24) | (value << 16) | (value << 8) | value; 3887 #elif PCRE2_CODE_UNIT_WIDTH == 16 3888 #define SSE2_COMPARE_TYPE_INDEX 1 3889 return (value << 16) | value; 3890 #elif PCRE2_CODE_UNIT_WIDTH == 32 3891 #define SSE2_COMPARE_TYPE_INDEX 2 3892 return value; 3893 #else 3894 #error "Unsupported unit width" 3895 #endif 3896 } 3897 3898 static SLJIT_INLINE void fast_forward_first_char2_sse2(compiler_common *common, PCRE2_UCHAR char1, PCRE2_UCHAR char2) 3899 { 3900 DEFINE_COMPILER; 3901 struct sljit_label *start; 3902 struct sljit_jump *quit[3]; 3903 struct sljit_jump *nomatch; 3904 sljit_u8 instruction[8]; 3905 sljit_s32 tmp1_ind = sljit_get_register_index(TMP1); 3906 sljit_s32 tmp2_ind = sljit_get_register_index(TMP2); 3907 sljit_s32 str_ptr_ind = sljit_get_register_index(STR_PTR); 3908 BOOL load_twice = FALSE; 3909 PCRE2_UCHAR bit; 3910 3911 bit = char1 ^ char2; 3912 if (!is_powerof2(bit)) 3913 bit = 0; 3914 3915 if ((char1 != char2) && bit == 0) 3916 load_twice = TRUE; 3917 3918 quit[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 3919 3920 /* First part (unaligned start) */ 3921 3922 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(char1 | bit)); 3923 3924 SLJIT_ASSERT(tmp1_ind < 8 && tmp2_ind == 1); 3925 3926 /* MOVD xmm, r/m32 */ 3927 instruction[0] = 0x66; 3928 instruction[1] = 0x0f; 3929 instruction[2] = 0x6e; 3930 instruction[3] = 0xc0 | (2 << 3) | tmp1_ind; 3931 sljit_emit_op_custom(compiler, instruction, 4); 3932 3933 if (char1 != char2) 3934 { 3935 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(bit != 0 ? bit : char2)); 3936 3937 /* MOVD xmm, r/m32 */ 3938 instruction[3] = 0xc0 | (3 << 3) | tmp1_ind; 3939 sljit_emit_op_custom(compiler, instruction, 4); 3940 } 3941 3942 /* PSHUFD xmm1, xmm2/m128, imm8 */ 3943 instruction[2] = 0x70; 3944 instruction[3] = 0xc0 | (2 << 3) | 2; 3945 instruction[4] = 0; 3946 sljit_emit_op_custom(compiler, instruction, 5); 3947 3948 if (char1 != char2) 3949 { 3950 /* PSHUFD xmm1, xmm2/m128, imm8 */ 3951 instruction[3] = 0xc0 | (3 << 3) | 3; 3952 instruction[4] = 0; 3953 sljit_emit_op_custom(compiler, instruction, 5); 3954 } 3955 3956 OP2(SLJIT_AND, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 0xf); 3957 OP2(SLJIT_AND, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, ~0xf); 3958 3959 /* MOVDQA xmm1, xmm2/m128 */ 3960 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 3961 3962 if (str_ptr_ind < 8) 3963 { 3964 instruction[2] = 0x6f; 3965 instruction[3] = (0 << 3) | str_ptr_ind; 3966 sljit_emit_op_custom(compiler, instruction, 4); 3967 3968 if (load_twice) 3969 { 3970 instruction[3] = (1 << 3) | str_ptr_ind; 3971 sljit_emit_op_custom(compiler, instruction, 4); 3972 } 3973 } 3974 else 3975 { 3976 instruction[1] = 0x41; 3977 instruction[2] = 0x0f; 3978 instruction[3] = 0x6f; 3979 instruction[4] = (0 << 3) | (str_ptr_ind & 0x7); 3980 sljit_emit_op_custom(compiler, instruction, 5); 3981 3982 if (load_twice) 3983 { 3984 instruction[4] = (1 << 3) | str_ptr_ind; 3985 sljit_emit_op_custom(compiler, instruction, 5); 3986 } 3987 instruction[1] = 0x0f; 3988 } 3989 3990 #else 3991 3992 instruction[2] = 0x6f; 3993 instruction[3] = (0 << 3) | str_ptr_ind; 3994 sljit_emit_op_custom(compiler, instruction, 4); 3995 3996 if (load_twice) 3997 { 3998 instruction[3] = (1 << 3) | str_ptr_ind; 3999 sljit_emit_op_custom(compiler, instruction, 4); 4000 } 4001 4002 #endif 4003 4004 if (bit != 0) 4005 { 4006 /* POR xmm1, xmm2/m128 */ 4007 instruction[2] = 0xeb; 4008 instruction[3] = 0xc0 | (0 << 3) | 3; 4009 sljit_emit_op_custom(compiler, instruction, 4); 4010 } 4011 4012 /* PCMPEQB/W/D xmm1, xmm2/m128 */ 4013 instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX; 4014 instruction[3] = 0xc0 | (0 << 3) | 2; 4015 sljit_emit_op_custom(compiler, instruction, 4); 4016 4017 if (load_twice) 4018 { 4019 instruction[3] = 0xc0 | (1 << 3) | 3; 4020 sljit_emit_op_custom(compiler, instruction, 4); 4021 } 4022 4023 /* PMOVMSKB reg, xmm */ 4024 instruction[2] = 0xd7; 4025 instruction[3] = 0xc0 | (tmp1_ind << 3) | 0; 4026 sljit_emit_op_custom(compiler, instruction, 4); 4027 4028 if (load_twice) 4029 { 4030 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP2, 0); 4031 instruction[3] = 0xc0 | (tmp2_ind << 3) | 1; 4032 sljit_emit_op_custom(compiler, instruction, 4); 4033 4034 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 4035 OP1(SLJIT_MOV, TMP2, 0, RETURN_ADDR, 0); 4036 } 4037 4038 OP2(SLJIT_ASHR, TMP1, 0, TMP1, 0, TMP2, 0); 4039 4040 /* BSF r32, r/m32 */ 4041 instruction[0] = 0x0f; 4042 instruction[1] = 0xbc; 4043 instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind; 4044 sljit_emit_op_custom(compiler, instruction, 3); 4045 4046 nomatch = JUMP(SLJIT_ZERO); 4047 4048 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 4049 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4050 quit[1] = JUMP(SLJIT_JUMP); 4051 4052 JUMPHERE(nomatch); 4053 4054 start = LABEL(); 4055 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 16); 4056 quit[2] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4057 4058 /* Second part (aligned) */ 4059 4060 instruction[0] = 0x66; 4061 instruction[1] = 0x0f; 4062 4063 /* MOVDQA xmm1, xmm2/m128 */ 4064 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 4065 4066 if (str_ptr_ind < 8) 4067 { 4068 instruction[2] = 0x6f; 4069 instruction[3] = (0 << 3) | str_ptr_ind; 4070 sljit_emit_op_custom(compiler, instruction, 4); 4071 4072 if (load_twice) 4073 { 4074 instruction[3] = (1 << 3) | str_ptr_ind; 4075 sljit_emit_op_custom(compiler, instruction, 4); 4076 } 4077 } 4078 else 4079 { 4080 instruction[1] = 0x41; 4081 instruction[2] = 0x0f; 4082 instruction[3] = 0x6f; 4083 instruction[4] = (0 << 3) | (str_ptr_ind & 0x7); 4084 sljit_emit_op_custom(compiler, instruction, 5); 4085 4086 if (load_twice) 4087 { 4088 instruction[4] = (1 << 3) | str_ptr_ind; 4089 sljit_emit_op_custom(compiler, instruction, 5); 4090 } 4091 instruction[1] = 0x0f; 4092 } 4093 4094 #else 4095 4096 instruction[2] = 0x6f; 4097 instruction[3] = (0 << 3) | str_ptr_ind; 4098 sljit_emit_op_custom(compiler, instruction, 4); 4099 4100 if (load_twice) 4101 { 4102 instruction[3] = (1 << 3) | str_ptr_ind; 4103 sljit_emit_op_custom(compiler, instruction, 4); 4104 } 4105 4106 #endif 4107 4108 if (bit != 0) 4109 { 4110 /* POR xmm1, xmm2/m128 */ 4111 instruction[2] = 0xeb; 4112 instruction[3] = 0xc0 | (0 << 3) | 3; 4113 sljit_emit_op_custom(compiler, instruction, 4); 4114 } 4115 4116 /* PCMPEQB/W/D xmm1, xmm2/m128 */ 4117 instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX; 4118 instruction[3] = 0xc0 | (0 << 3) | 2; 4119 sljit_emit_op_custom(compiler, instruction, 4); 4120 4121 if (load_twice) 4122 { 4123 instruction[3] = 0xc0 | (1 << 3) | 3; 4124 sljit_emit_op_custom(compiler, instruction, 4); 4125 } 4126 4127 /* PMOVMSKB reg, xmm */ 4128 instruction[2] = 0xd7; 4129 instruction[3] = 0xc0 | (tmp1_ind << 3) | 0; 4130 sljit_emit_op_custom(compiler, instruction, 4); 4131 4132 if (load_twice) 4133 { 4134 instruction[3] = 0xc0 | (tmp2_ind << 3) | 1; 4135 sljit_emit_op_custom(compiler, instruction, 4); 4136 4137 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); 4138 } 4139 4140 /* BSF r32, r/m32 */ 4141 instruction[0] = 0x0f; 4142 instruction[1] = 0xbc; 4143 instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind; 4144 sljit_emit_op_custom(compiler, instruction, 3); 4145 4146 JUMPTO(SLJIT_ZERO, start); 4147 4148 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4149 4150 start = LABEL(); 4151 SET_LABEL(quit[0], start); 4152 SET_LABEL(quit[1], start); 4153 SET_LABEL(quit[2], start); 4154 } 4155 4156 #undef SSE2_COMPARE_TYPE_INDEX 4157 4158 #endif 4159 4160 static void fast_forward_first_char2(compiler_common *common, PCRE2_UCHAR char1, PCRE2_UCHAR char2, sljit_s32 offset) 4161 { 4162 DEFINE_COMPILER; 4163 struct sljit_label *start; 4164 struct sljit_jump *quit; 4165 struct sljit_jump *found; 4166 PCRE2_UCHAR mask; 4167 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4168 struct sljit_label *utf_start = NULL; 4169 struct sljit_jump *utf_quit = NULL; 4170 #endif 4171 BOOL has_match_end = (common->match_end_ptr != 0); 4172 4173 if (offset > 0) 4174 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset)); 4175 4176 if (has_match_end) 4177 { 4178 OP1(SLJIT_MOV, TMP3, 0, STR_END, 0); 4179 4180 OP2(SLJIT_ADD, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, SLJIT_IMM, IN_UCHARS(offset + 1)); 4181 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4182 if (sljit_x86_is_cmov_available()) 4183 { 4184 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_END, 0, TMP3, 0); 4185 sljit_x86_emit_cmov(compiler, SLJIT_GREATER, STR_END, TMP3, 0); 4186 } 4187 #endif 4188 { 4189 quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP3, 0); 4190 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4191 JUMPHERE(quit); 4192 } 4193 } 4194 4195 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4196 if (common->utf && offset > 0) 4197 utf_start = LABEL(); 4198 #endif 4199 4200 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4201 4202 /* SSE2 accelerated first character search. */ 4203 4204 if (sljit_x86_is_sse2_available()) 4205 { 4206 fast_forward_first_char2_sse2(common, char1, char2); 4207 4208 SLJIT_ASSERT(common->mode == PCRE2_JIT_COMPLETE || offset == 0); 4209 if (common->mode == PCRE2_JIT_COMPLETE) 4210 { 4211 /* In complete mode, we don't need to run a match when STR_PTR == STR_END. */ 4212 SLJIT_ASSERT(common->forced_quit_label == NULL); 4213 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE2_ERROR_NOMATCH); 4214 add_jump(compiler, &common->forced_quit, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0)); 4215 4216 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4217 if (common->utf && offset > 0) 4218 { 4219 SLJIT_ASSERT(common->mode == PCRE2_JIT_COMPLETE); 4220 4221 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset)); 4222 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4223 #if PCRE2_CODE_UNIT_WIDTH == 8 4224 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0); 4225 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start); 4226 #elif PCRE2_CODE_UNIT_WIDTH == 16 4227 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 4228 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start); 4229 #else 4230 #error "Unknown code width" 4231 #endif 4232 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4233 } 4234 #endif 4235 4236 if (offset > 0) 4237 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset)); 4238 } 4239 else if (sljit_x86_is_cmov_available()) 4240 { 4241 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, STR_END, 0); 4242 sljit_x86_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, has_match_end ? SLJIT_MEM1(SLJIT_SP) : STR_END, has_match_end ? common->match_end_ptr : 0); 4243 } 4244 else 4245 { 4246 quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0); 4247 OP1(SLJIT_MOV, STR_PTR, 0, has_match_end ? SLJIT_MEM1(SLJIT_SP) : STR_END, has_match_end ? common->match_end_ptr : 0); 4248 JUMPHERE(quit); 4249 } 4250 4251 if (has_match_end) 4252 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4253 return; 4254 } 4255 4256 #endif 4257 4258 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4259 4260 start = LABEL(); 4261 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 4262 4263 if (char1 == char2) 4264 found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1); 4265 else 4266 { 4267 mask = char1 ^ char2; 4268 if (is_powerof2(mask)) 4269 { 4270 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask); 4271 found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1 | mask); 4272 } 4273 else 4274 { 4275 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char1); 4276 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 4277 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char2); 4278 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 4279 found = JUMP(SLJIT_NOT_ZERO); 4280 } 4281 } 4282 4283 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4284 CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, start); 4285 4286 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4287 if (common->utf && offset > 0) 4288 utf_quit = JUMP(SLJIT_JUMP); 4289 #endif 4290 4291 JUMPHERE(found); 4292 4293 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4294 if (common->utf && offset > 0) 4295 { 4296 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset)); 4297 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4298 #if PCRE2_CODE_UNIT_WIDTH == 8 4299 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0); 4300 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start); 4301 #elif PCRE2_CODE_UNIT_WIDTH == 16 4302 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 4303 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start); 4304 #else 4305 #error "Unknown code width" 4306 #endif 4307 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4308 JUMPHERE(utf_quit); 4309 } 4310 #endif 4311 4312 JUMPHERE(quit); 4313 4314 if (has_match_end) 4315 { 4316 quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0); 4317 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr); 4318 if (offset > 0) 4319 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset)); 4320 JUMPHERE(quit); 4321 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4322 } 4323 4324 if (offset > 0) 4325 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset)); 4326 } 4327 4328 static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common) 4329 { 4330 DEFINE_COMPILER; 4331 struct sljit_label *start; 4332 struct sljit_jump *quit; 4333 struct sljit_jump *match; 4334 /* bytes[0] represent the number of characters between 0 4335 and MAX_N_BYTES - 1, 255 represents any character. */ 4336 PCRE2_UCHAR chars[MAX_N_CHARS * MAX_DIFF_CHARS]; 4337 sljit_s32 offset; 4338 PCRE2_UCHAR mask; 4339 PCRE2_UCHAR *char_set, *char_set_end; 4340 int i, max, from; 4341 int range_right = -1, range_len; 4342 sljit_u8 *update_table = NULL; 4343 BOOL in_range; 4344 sljit_u32 rec_count; 4345 4346 for (i = 0; i < MAX_N_CHARS; i++) 4347 chars[i * MAX_DIFF_CHARS] = 0; 4348 4349 rec_count = 10000; 4350 max = scan_prefix(common, common->start, chars, MAX_N_CHARS, &rec_count); 4351 4352 if (max < 1) 4353 return FALSE; 4354 4355 in_range = FALSE; 4356 /* Prevent compiler "uninitialized" warning */ 4357 from = 0; 4358 range_len = 4 /* minimum length */ - 1; 4359 for (i = 0; i <= max; i++) 4360 { 4361 if (in_range && (i - from) > range_len && (chars[(i - 1) * MAX_DIFF_CHARS] < 255)) 4362 { 4363 range_len = i - from; 4364 range_right = i - 1; 4365 } 4366 4367 if (i < max && chars[i * MAX_DIFF_CHARS] < 255) 4368 { 4369 SLJIT_ASSERT(chars[i * MAX_DIFF_CHARS] > 0); 4370 if (!in_range) 4371 { 4372 in_range = TRUE; 4373 from = i; 4374 } 4375 } 4376 else 4377 in_range = FALSE; 4378 } 4379 4380 if (range_right >= 0) 4381 { 4382 update_table = (sljit_u8 *)allocate_read_only_data(common, 256); 4383 if (update_table == NULL) 4384 return TRUE; 4385 memset(update_table, IN_UCHARS(range_len), 256); 4386 4387 for (i = 0; i < range_len; i++) 4388 { 4389 char_set = chars + ((range_right - i) * MAX_DIFF_CHARS); 4390 SLJIT_ASSERT(char_set[0] > 0 && char_set[0] < 255); 4391 char_set_end = char_set + char_set[0]; 4392 char_set++; 4393 while (char_set <= char_set_end) 4394 { 4395 if (update_table[(*char_set) & 0xff] > IN_UCHARS(i)) 4396 update_table[(*char_set) & 0xff] = IN_UCHARS(i); 4397 char_set++; 4398 } 4399 } 4400 } 4401 4402 offset = -1; 4403 /* Scan forward. */ 4404 for (i = 0; i < max; i++) 4405 { 4406 if (offset == -1) 4407 { 4408 if (chars[i * MAX_DIFF_CHARS] <= 2) 4409 offset = i; 4410 } 4411 else if (chars[offset * MAX_DIFF_CHARS] == 2 && chars[i * MAX_DIFF_CHARS] <= 2) 4412 { 4413 if (chars[i * MAX_DIFF_CHARS] == 1) 4414 offset = i; 4415 else 4416 { 4417 mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2]; 4418 if (!is_powerof2(mask)) 4419 { 4420 mask = chars[i * MAX_DIFF_CHARS + 1] ^ chars[i * MAX_DIFF_CHARS + 2]; 4421 if (is_powerof2(mask)) 4422 offset = i; 4423 } 4424 } 4425 } 4426 } 4427 4428 if (range_right < 0) 4429 { 4430 if (offset < 0) 4431 return FALSE; 4432 SLJIT_ASSERT(chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2); 4433 /* Works regardless the value is 1 or 2. */ 4434 mask = chars[offset * MAX_DIFF_CHARS + chars[offset * MAX_DIFF_CHARS]]; 4435 fast_forward_first_char2(common, chars[offset * MAX_DIFF_CHARS + 1], mask, offset); 4436 return TRUE; 4437 } 4438 4439 if (range_right == offset) 4440 offset = -1; 4441 4442 SLJIT_ASSERT(offset == -1 || (chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2)); 4443 4444 max -= 1; 4445 SLJIT_ASSERT(max > 0); 4446 if (common->match_end_ptr != 0) 4447 { 4448 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr); 4449 OP1(SLJIT_MOV, TMP3, 0, STR_END, 0); 4450 OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max)); 4451 quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0); 4452 OP1(SLJIT_MOV, STR_END, 0, TMP1, 0); 4453 JUMPHERE(quit); 4454 } 4455 else 4456 OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max)); 4457 4458 SLJIT_ASSERT(range_right >= 0); 4459 4460 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 4461 OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table); 4462 #endif 4463 4464 start = LABEL(); 4465 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4466 4467 #if PCRE2_CODE_UNIT_WIDTH == 8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 4468 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right)); 4469 #else 4470 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1); 4471 #endif 4472 4473 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 4474 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0); 4475 #else 4476 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table); 4477 #endif 4478 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4479 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start); 4480 4481 if (offset >= 0) 4482 { 4483 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offset)); 4484 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4485 4486 if (chars[offset * MAX_DIFF_CHARS] == 1) 4487 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1], start); 4488 else 4489 { 4490 mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2]; 4491 if (is_powerof2(mask)) 4492 { 4493 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask); 4494 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1] | mask, start); 4495 } 4496 else 4497 { 4498 match = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1]); 4499 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 2], start); 4500 JUMPHERE(match); 4501 } 4502 } 4503 } 4504 4505 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 4506 if (common->utf && offset != 0) 4507 { 4508 if (offset < 0) 4509 { 4510 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 4511 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4512 } 4513 else 4514 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1)); 4515 #if PCRE2_CODE_UNIT_WIDTH == 8 4516 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0); 4517 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, start); 4518 #elif PCRE2_CODE_UNIT_WIDTH == 16 4519 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 4520 CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, start); 4521 #else 4522 #error "Unknown code width" 4523 #endif 4524 if (offset < 0) 4525 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4526 } 4527 #endif 4528 4529 if (offset >= 0) 4530 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4531 4532 JUMPHERE(quit); 4533 4534 if (common->match_end_ptr != 0) 4535 { 4536 if (range_right >= 0) 4537 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr); 4538 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4539 if (range_right >= 0) 4540 { 4541 quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0); 4542 OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0); 4543 JUMPHERE(quit); 4544 } 4545 } 4546 else 4547 OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max)); 4548 return TRUE; 4549 } 4550 4551 #undef MAX_N_CHARS 4552 4553 static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, PCRE2_UCHAR first_char, BOOL caseless) 4554 { 4555 PCRE2_UCHAR oc; 4556 4557 oc = first_char; 4558 if (caseless) 4559 { 4560 oc = TABLE_GET(first_char, common->fcc, first_char); 4561 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8 4562 if (first_char > 127 && common->utf) 4563 oc = UCD_OTHERCASE(first_char); 4564 #endif 4565 } 4566 4567 fast_forward_first_char2(common, first_char, oc, 0); 4568 } 4569 4570 static SLJIT_INLINE void fast_forward_newline(compiler_common *common) 4571 { 4572 DEFINE_COMPILER; 4573 struct sljit_label *loop; 4574 struct sljit_jump *lastchar; 4575 struct sljit_jump *firstchar; 4576 struct sljit_jump *quit; 4577 struct sljit_jump *foundcr = NULL; 4578 struct sljit_jump *notfoundnl; 4579 jump_list *newline = NULL; 4580 4581 if (common->match_end_ptr != 0) 4582 { 4583 OP1(SLJIT_MOV, TMP3, 0, STR_END, 0); 4584 OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr); 4585 } 4586 4587 if (common->nltype == NLTYPE_FIXED && common->newline > 255) 4588 { 4589 lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4590 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 4591 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); 4592 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin)); 4593 firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0); 4594 4595 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2)); 4596 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0); 4597 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER_EQUAL); 4598 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 4599 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT); 4600 #endif 4601 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 4602 4603 loop = LABEL(); 4604 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4605 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4606 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2)); 4607 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1)); 4608 CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop); 4609 CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop); 4610 4611 JUMPHERE(quit); 4612 JUMPHERE(firstchar); 4613 JUMPHERE(lastchar); 4614 4615 if (common->match_end_ptr != 0) 4616 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4617 return; 4618 } 4619 4620 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 4621 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); 4622 firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0); 4623 skip_char_back(common); 4624 4625 loop = LABEL(); 4626 common->ff_newline_shortcut = loop; 4627 4628 read_char_range(common, common->nlmin, common->nlmax, TRUE); 4629 lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4630 if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF) 4631 foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR); 4632 check_newlinechar(common, common->nltype, &newline, FALSE); 4633 set_jumps(newline, loop); 4634 4635 if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF) 4636 { 4637 quit = JUMP(SLJIT_JUMP); 4638 JUMPHERE(foundcr); 4639 notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4640 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 4641 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL); 4642 OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 4643 #if PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 4644 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT); 4645 #endif 4646 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4647 JUMPHERE(notfoundnl); 4648 JUMPHERE(quit); 4649 } 4650 JUMPHERE(lastchar); 4651 JUMPHERE(firstchar); 4652 4653 if (common->match_end_ptr != 0) 4654 OP1(SLJIT_MOV, STR_END, 0, TMP3, 0); 4655 } 4656 4657 static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks); 4658 4659 static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, const sljit_u8 *start_bits) 4660 { 4661 DEFINE_COMPILER; 4662 struct sljit_label *start; 4663 struct sljit_jump *quit; 4664 struct sljit_jump *found = NULL; 4665 jump_list *matches = NULL; 4666 #if PCRE2_CODE_UNIT_WIDTH != 8 4667 struct sljit_jump *jump; 4668 #endif 4669 4670 if (common->match_end_ptr != 0) 4671 { 4672 OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0); 4673 OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr); 4674 } 4675 4676 start = LABEL(); 4677 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 4678 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); 4679 #ifdef SUPPORT_UNICODE 4680 if (common->utf) 4681 OP1(SLJIT_MOV, TMP3, 0, TMP1, 0); 4682 #endif 4683 4684 if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches)) 4685 { 4686 #if PCRE2_CODE_UNIT_WIDTH != 8 4687 jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 255); 4688 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255); 4689 JUMPHERE(jump); 4690 #endif 4691 OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7); 4692 OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3); 4693 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits); 4694 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0); 4695 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0); 4696 found = JUMP(SLJIT_NOT_ZERO); 4697 } 4698 4699 #ifdef SUPPORT_UNICODE 4700 if (common->utf) 4701 OP1(SLJIT_MOV, TMP1, 0, TMP3, 0); 4702 #endif 4703 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4704 #ifdef SUPPORT_UNICODE 4705 #if PCRE2_CODE_UNIT_WIDTH == 8 4706 if (common->utf) 4707 { 4708 CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start); 4709 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0); 4710 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4711 } 4712 #elif PCRE2_CODE_UNIT_WIDTH == 16 4713 if (common->utf) 4714 { 4715 CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start); 4716 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00); 4717 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800); 4718 OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 4719 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1); 4720 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); 4721 } 4722 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16] */ 4723 #endif /* SUPPORT_UNICODE */ 4724 JUMPTO(SLJIT_JUMP, start); 4725 if (found != NULL) 4726 JUMPHERE(found); 4727 if (matches != NULL) 4728 set_jumps(matches, LABEL()); 4729 JUMPHERE(quit); 4730 4731 if (common->match_end_ptr != 0) 4732 OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0); 4733 } 4734 4735 static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, PCRE2_UCHAR req_char, BOOL caseless, BOOL has_firstchar) 4736 { 4737 DEFINE_COMPILER; 4738 struct sljit_label *loop; 4739 struct sljit_jump *toolong; 4740 struct sljit_jump *alreadyfound; 4741 struct sljit_jump *found; 4742 struct sljit_jump *foundoc = NULL; 4743 struct sljit_jump *notfound; 4744 sljit_u32 oc, bit; 4745 4746 SLJIT_ASSERT(common->req_char_ptr != 0); 4747 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr); 4748 OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_CU_MAX); 4749 toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0); 4750 alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0); 4751 4752 if (has_firstchar) 4753 OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 4754 else 4755 OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0); 4756 4757 loop = LABEL(); 4758 notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0); 4759 4760 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0); 4761 oc = req_char; 4762 if (caseless) 4763 { 4764 oc = TABLE_GET(req_char, common->fcc, req_char); 4765 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8 4766 if (req_char > 127 && common->utf) 4767 oc = UCD_OTHERCASE(req_char); 4768 #endif 4769 } 4770 if (req_char == oc) 4771 found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char); 4772 else 4773 { 4774 bit = req_char ^ oc; 4775 if (is_powerof2(bit)) 4776 { 4777 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit); 4778 found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit); 4779 } 4780 else 4781 { 4782 found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char); 4783 foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc); 4784 } 4785 } 4786 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1)); 4787 JUMPTO(SLJIT_JUMP, loop); 4788 4789 JUMPHERE(found); 4790 if (foundoc) 4791 JUMPHERE(foundoc); 4792 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0); 4793 JUMPHERE(alreadyfound); 4794 JUMPHERE(toolong); 4795 return notfound; 4796 } 4797 4798 static void do_revertframes(compiler_common *common) 4799 { 4800 DEFINE_COMPILER; 4801 struct sljit_jump *jump; 4802 struct sljit_label *mainloop; 4803 4804 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 4805 OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0); 4806 GET_LOCAL_BASE(TMP3, 0, 0); 4807 4808 /* Drop frames until we reach STACK_TOP. */ 4809 mainloop = LABEL(); 4810 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0); 4811 OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0); 4812 jump = JUMP(SLJIT_SIG_LESS_EQUAL); 4813 4814 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0); 4815 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw)); 4816 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw)); 4817 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_sw)); 4818 JUMPTO(SLJIT_JUMP, mainloop); 4819 4820 JUMPHERE(jump); 4821 jump = JUMP(SLJIT_SIG_LESS); 4822 /* End of dropping frames. */ 4823 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 4824 4825 JUMPHERE(jump); 4826 OP1(SLJIT_NEG, TMP2, 0, TMP2, 0); 4827 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0); 4828 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw)); 4829 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw)); 4830 JUMPTO(SLJIT_JUMP, mainloop); 4831 } 4832 4833 static void check_wordboundary(compiler_common *common) 4834 { 4835 DEFINE_COMPILER; 4836 struct sljit_jump *skipread; 4837 jump_list *skipread_list = NULL; 4838 #if PCRE2_CODE_UNIT_WIDTH != 8 || defined SUPPORT_UNICODE 4839 struct sljit_jump *jump; 4840 #endif 4841 4842 SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16); 4843 4844 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0); 4845 /* Get type of the previous char, and put it to LOCALS1. */ 4846 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 4847 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin)); 4848 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0); 4849 skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0); 4850 skip_char_back(common); 4851 check_start_used_ptr(common); 4852 read_char(common); 4853 4854 /* Testing char type. */ 4855 #ifdef SUPPORT_UNICODE 4856 if (common->use_ucp) 4857 { 4858 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1); 4859 jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE); 4860 add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL)); 4861 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll); 4862 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll); 4863 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 4864 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll); 4865 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd); 4866 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 4867 JUMPHERE(jump); 4868 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0); 4869 } 4870 else 4871 #endif 4872 { 4873 #if PCRE2_CODE_UNIT_WIDTH != 8 4874 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 4875 #elif defined SUPPORT_UNICODE 4876 /* Here LOCALS1 has already been zeroed. */ 4877 jump = NULL; 4878 if (common->utf) 4879 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 4880 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 4881 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes); 4882 OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */); 4883 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1); 4884 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0); 4885 #if PCRE2_CODE_UNIT_WIDTH != 8 4886 JUMPHERE(jump); 4887 #elif defined SUPPORT_UNICODE 4888 if (jump != NULL) 4889 JUMPHERE(jump); 4890 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 4891 } 4892 JUMPHERE(skipread); 4893 4894 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); 4895 check_str_end(common, &skipread_list); 4896 peek_char(common, READ_CHAR_MAX); 4897 4898 /* Testing char type. This is a code duplication. */ 4899 #ifdef SUPPORT_UNICODE 4900 if (common->use_ucp) 4901 { 4902 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1); 4903 jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE); 4904 add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL)); 4905 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll); 4906 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll); 4907 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 4908 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll); 4909 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd); 4910 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 4911 JUMPHERE(jump); 4912 } 4913 else 4914 #endif 4915 { 4916 #if PCRE2_CODE_UNIT_WIDTH != 8 4917 /* TMP2 may be destroyed by peek_char. */ 4918 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); 4919 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 4920 #elif defined SUPPORT_UNICODE 4921 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); 4922 jump = NULL; 4923 if (common->utf) 4924 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 4925 #endif 4926 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes); 4927 OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */); 4928 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1); 4929 #if PCRE2_CODE_UNIT_WIDTH != 8 4930 JUMPHERE(jump); 4931 #elif defined SUPPORT_UNICODE 4932 if (jump != NULL) 4933 JUMPHERE(jump); 4934 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 4935 } 4936 set_jumps(skipread_list, LABEL()); 4937 4938 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1); 4939 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0); 4940 } 4941 4942 static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks) 4943 { 4944 /* May destroy TMP1. */ 4945 DEFINE_COMPILER; 4946 int ranges[MAX_RANGE_SIZE]; 4947 sljit_u8 bit, cbit, all; 4948 int i, byte, length = 0; 4949 4950 bit = bits[0] & 0x1; 4951 /* All bits will be zero or one (since bit is zero or one). */ 4952 all = -bit; 4953 4954 for (i = 0; i < 256; ) 4955 { 4956 byte = i >> 3; 4957 if ((i & 0x7) == 0 && bits[byte] == all) 4958 i += 8; 4959 else 4960 { 4961 cbit = (bits[byte] >> (i & 0x7)) & 0x1; 4962 if (cbit != bit) 4963 { 4964 if (length >= MAX_RANGE_SIZE) 4965 return FALSE; 4966 ranges[length] = i; 4967 length++; 4968 bit = cbit; 4969 all = -cbit; 4970 } 4971 i++; 4972 } 4973 } 4974 4975 if (((bit == 0) && nclass) || ((bit == 1) && !nclass)) 4976 { 4977 if (length >= MAX_RANGE_SIZE) 4978 return FALSE; 4979 ranges[length] = 256; 4980 length++; 4981 } 4982 4983 if (length < 0 || length > 4) 4984 return FALSE; 4985 4986 bit = bits[0] & 0x1; 4987 if (invert) bit ^= 0x1; 4988 4989 /* No character is accepted. */ 4990 if (length == 0 && bit == 0) 4991 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 4992 4993 switch(length) 4994 { 4995 case 0: 4996 /* When bit != 0, all characters are accepted. */ 4997 return TRUE; 4998 4999 case 1: 5000 add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0])); 5001 return TRUE; 5002 5003 case 2: 5004 if (ranges[0] + 1 != ranges[1]) 5005 { 5006 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]); 5007 add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0])); 5008 } 5009 else 5010 add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0])); 5011 return TRUE; 5012 5013 case 3: 5014 if (bit != 0) 5015 { 5016 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2])); 5017 if (ranges[0] + 1 != ranges[1]) 5018 { 5019 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]); 5020 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0])); 5021 } 5022 else 5023 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0])); 5024 return TRUE; 5025 } 5026 5027 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[0])); 5028 if (ranges[1] + 1 != ranges[2]) 5029 { 5030 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]); 5031 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1])); 5032 } 5033 else 5034 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1])); 5035 return TRUE; 5036 5037 case 4: 5038 if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2]) 5039 && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2] 5040 && (ranges[1] & (ranges[2] - ranges[0])) == 0 5041 && is_powerof2(ranges[2] - ranges[0])) 5042 { 5043 SLJIT_ASSERT((ranges[0] & (ranges[2] - ranges[0])) == 0 && (ranges[2] & ranges[3] & (ranges[2] - ranges[0])) != 0); 5044 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]); 5045 if (ranges[2] + 1 != ranges[3]) 5046 { 5047 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]); 5048 add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2])); 5049 } 5050 else 5051 add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2])); 5052 return TRUE; 5053 } 5054 5055 if (bit != 0) 5056 { 5057 i = 0; 5058 if (ranges[0] + 1 != ranges[1]) 5059 { 5060 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]); 5061 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0])); 5062 i = ranges[0]; 5063 } 5064 else 5065 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0])); 5066 5067 if (ranges[2] + 1 != ranges[3]) 5068 { 5069 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i); 5070 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2])); 5071 } 5072 else 5073 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i)); 5074 return TRUE; 5075 } 5076 5077 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]); 5078 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0])); 5079 if (ranges[1] + 1 != ranges[2]) 5080 { 5081 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]); 5082 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1])); 5083 } 5084 else 5085 add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0])); 5086 return TRUE; 5087 5088 default: 5089 SLJIT_ASSERT_STOP(); 5090 return FALSE; 5091 } 5092 } 5093 5094 static void check_anynewline(compiler_common *common) 5095 { 5096 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ 5097 DEFINE_COMPILER; 5098 5099 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 5100 5101 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a); 5102 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a); 5103 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5104 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a); 5105 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 5106 #if PCRE2_CODE_UNIT_WIDTH == 8 5107 if (common->utf) 5108 { 5109 #endif 5110 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5111 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1); 5112 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a); 5113 #if PCRE2_CODE_UNIT_WIDTH == 8 5114 } 5115 #endif 5116 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */ 5117 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5118 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 5119 } 5120 5121 static void check_hspace(compiler_common *common) 5122 { 5123 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ 5124 DEFINE_COMPILER; 5125 5126 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 5127 5128 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09); 5129 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5130 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20); 5131 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5132 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0); 5133 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 5134 #if PCRE2_CODE_UNIT_WIDTH == 8 5135 if (common->utf) 5136 { 5137 #endif 5138 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5139 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680); 5140 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5141 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e); 5142 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5143 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000); 5144 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000); 5145 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 5146 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000); 5147 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5148 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000); 5149 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5150 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000); 5151 #if PCRE2_CODE_UNIT_WIDTH == 8 5152 } 5153 #endif 5154 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */ 5155 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5156 5157 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 5158 } 5159 5160 static void check_vspace(compiler_common *common) 5161 { 5162 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ 5163 DEFINE_COMPILER; 5164 5165 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 5166 5167 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a); 5168 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a); 5169 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5170 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a); 5171 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 5172 #if PCRE2_CODE_UNIT_WIDTH == 8 5173 if (common->utf) 5174 { 5175 #endif 5176 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5177 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1); 5178 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a); 5179 #if PCRE2_CODE_UNIT_WIDTH == 8 5180 } 5181 #endif 5182 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */ 5183 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5184 5185 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 5186 } 5187 5188 #define CHAR1 STR_END 5189 #define CHAR2 STACK_TOP 5190 5191 static void do_casefulcmp(compiler_common *common) 5192 { 5193 DEFINE_COMPILER; 5194 struct sljit_jump *jump; 5195 struct sljit_label *label; 5196 5197 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 5198 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 5199 OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0); 5200 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR2, 0); 5201 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1)); 5202 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 5203 5204 label = LABEL(); 5205 OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1)); 5206 OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 5207 jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0); 5208 OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1)); 5209 JUMPTO(SLJIT_NOT_ZERO, label); 5210 5211 JUMPHERE(jump); 5212 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 5213 OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0); 5214 OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0); 5215 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 5216 } 5217 5218 #define LCC_TABLE STACK_LIMIT 5219 5220 static void do_caselesscmp(compiler_common *common) 5221 { 5222 DEFINE_COMPILER; 5223 struct sljit_jump *jump; 5224 struct sljit_label *label; 5225 5226 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0); 5227 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0); 5228 5229 OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0); 5230 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR1, 0); 5231 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, CHAR2, 0); 5232 OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc); 5233 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1)); 5234 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 5235 5236 label = LABEL(); 5237 OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1)); 5238 OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 5239 #if PCRE2_CODE_UNIT_WIDTH != 8 5240 jump = CMP(SLJIT_GREATER, CHAR1, 0, SLJIT_IMM, 255); 5241 #endif 5242 OP1(SLJIT_MOV_U8, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0); 5243 #if PCRE2_CODE_UNIT_WIDTH != 8 5244 JUMPHERE(jump); 5245 jump = CMP(SLJIT_GREATER, CHAR2, 0, SLJIT_IMM, 255); 5246 #endif 5247 OP1(SLJIT_MOV_U8, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0); 5248 #if PCRE2_CODE_UNIT_WIDTH != 8 5249 JUMPHERE(jump); 5250 #endif 5251 jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0); 5252 OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1)); 5253 JUMPTO(SLJIT_NOT_ZERO, label); 5254 5255 JUMPHERE(jump); 5256 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 5257 OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0); 5258 OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0); 5259 OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1); 5260 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); 5261 } 5262 5263 #undef LCC_TABLE 5264 #undef CHAR1 5265 #undef CHAR2 5266 5267 #if defined SUPPORT_UNICODE 5268 5269 static PCRE2_SPTR SLJIT_CALL do_utf_caselesscmp(PCRE2_SPTR src1, jit_arguments *args, PCRE2_SPTR end1) 5270 { 5271 /* This function would be ineffective to do in JIT level. */ 5272 sljit_u32 c1, c2; 5273 PCRE2_SPTR src2 = args->startchar_ptr; 5274 PCRE2_SPTR end2 = args->end; 5275 const ucd_record *ur; 5276 const sljit_u32 *pp; 5277 5278 while (src1 < end1) 5279 { 5280 if (src2 >= end2) 5281 return (PCRE2_SPTR)1; 5282 GETCHARINC(c1, src1); 5283 GETCHARINC(c2, src2); 5284 ur = GET_UCD(c2); 5285 if (c1 != c2 && c1 != c2 + ur->other_case) 5286 { 5287 pp = PRIV(ucd_caseless_sets) + ur->caseset; 5288 for (;;) 5289 { 5290 if (c1 < *pp) return NULL; 5291 if (c1 == *pp++) break; 5292 } 5293 } 5294 } 5295 return src2; 5296 } 5297 5298 #endif /* SUPPORT_UNICODE */ 5299 5300 static PCRE2_SPTR byte_sequence_compare(compiler_common *common, BOOL caseless, PCRE2_SPTR cc, 5301 compare_context *context, jump_list **backtracks) 5302 { 5303 DEFINE_COMPILER; 5304 unsigned int othercasebit = 0; 5305 PCRE2_SPTR othercasechar = NULL; 5306 #ifdef SUPPORT_UNICODE 5307 int utflength; 5308 #endif 5309 5310 if (caseless && char_has_othercase(common, cc)) 5311 { 5312 othercasebit = char_get_othercase_bit(common, cc); 5313 SLJIT_ASSERT(othercasebit); 5314 /* Extracting bit difference info. */ 5315 #if PCRE2_CODE_UNIT_WIDTH == 8 5316 othercasechar = cc + (othercasebit >> 8); 5317 othercasebit &= 0xff; 5318 #elif PCRE2_CODE_UNIT_WIDTH == 16 || PCRE2_CODE_UNIT_WIDTH == 32 5319 /* Note that this code only handles characters in the BMP. If there 5320 ever are characters outside the BMP whose othercase differs in only one 5321 bit from itself (there currently are none), this code will need to be 5322 revised for PCRE2_CODE_UNIT_WIDTH == 32. */ 5323 othercasechar = cc + (othercasebit >> 9); 5324 if ((othercasebit & 0x100) != 0) 5325 othercasebit = (othercasebit & 0xff) << 8; 5326 else 5327 othercasebit &= 0xff; 5328 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16|32] */ 5329 } 5330 5331 if (context->sourcereg == -1) 5332 { 5333 #if PCRE2_CODE_UNIT_WIDTH == 8 5334 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED 5335 if (context->length >= 4) 5336 OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5337 else if (context->length >= 2) 5338 OP1(SLJIT_MOV_U16, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5339 else 5340 #endif 5341 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5342 #elif PCRE2_CODE_UNIT_WIDTH == 16 5343 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED 5344 if (context->length >= 4) 5345 OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5346 else 5347 #endif 5348 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5349 #elif PCRE2_CODE_UNIT_WIDTH == 32 5350 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); 5351 #endif /* PCRE2_CODE_UNIT_WIDTH == [8|16|32] */ 5352 context->sourcereg = TMP2; 5353 } 5354 5355 #ifdef SUPPORT_UNICODE 5356 utflength = 1; 5357 if (common->utf && HAS_EXTRALEN(*cc)) 5358 utflength += GET_EXTRALEN(*cc); 5359 5360 do 5361 { 5362 #endif 5363 5364 context->length -= IN_UCHARS(1); 5365 #if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (PCRE2_CODE_UNIT_WIDTH == 8 || PCRE2_CODE_UNIT_WIDTH == 16) 5366 5367 /* Unaligned read is supported. */ 5368 if (othercasebit != 0 && othercasechar == cc) 5369 { 5370 context->c.asuchars[context->ucharptr] = *cc | othercasebit; 5371 context->oc.asuchars[context->ucharptr] = othercasebit; 5372 } 5373 else 5374 { 5375 context->c.asuchars[context->ucharptr] = *cc; 5376 context->oc.asuchars[context->ucharptr] = 0; 5377 } 5378 context->ucharptr++; 5379 5380 #if PCRE2_CODE_UNIT_WIDTH == 8 5381 if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1)) 5382 #else 5383 if (context->ucharptr >= 2 || context->length == 0) 5384 #endif 5385 { 5386 if (context->length >= 4) 5387 OP1(SLJIT_MOV_S32, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); 5388 else if (context->length >= 2) 5389 OP1(SLJIT_MOV_U16, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); 5390 #if PCRE2_CODE_UNIT_WIDTH == 8 5391 else if (context->length >= 1) 5392 OP1(SLJIT_MOV_U8, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); 5393 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 5394 context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1; 5395 5396 switch(context->ucharptr) 5397 { 5398 case 4 / sizeof(PCRE2_UCHAR): 5399 if (context->oc.asint != 0) 5400 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint); 5401 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint)); 5402 break; 5403 5404 case 2 / sizeof(PCRE2_UCHAR): 5405 if (context->oc.asushort != 0) 5406 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort); 5407 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort)); 5408 break; 5409 5410 #if PCRE2_CODE_UNIT_WIDTH == 8 5411 case 1: 5412 if (context->oc.asbyte != 0) 5413 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte); 5414 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte)); 5415 break; 5416 #endif 5417 5418 default: 5419 SLJIT_ASSERT_STOP(); 5420 break; 5421 } 5422 context->ucharptr = 0; 5423 } 5424 5425 #else 5426 5427 /* Unaligned read is unsupported or in 32 bit mode. */ 5428 if (context->length >= 1) 5429 OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); 5430 5431 context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1; 5432 5433 if (othercasebit != 0 && othercasechar == cc) 5434 { 5435 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit); 5436 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit)); 5437 } 5438 else 5439 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc)); 5440 5441 #endif 5442 5443 cc++; 5444 #ifdef SUPPORT_UNICODE 5445 utflength--; 5446 } 5447 while (utflength > 0); 5448 #endif 5449 5450 return cc; 5451 } 5452 5453 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8 5454 5455 #define SET_TYPE_OFFSET(value) \ 5456 if ((value) != typeoffset) \ 5457 { \ 5458 if ((value) < typeoffset) \ 5459 OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \ 5460 else \ 5461 OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \ 5462 } \ 5463 typeoffset = (value); 5464 5465 #define SET_CHAR_OFFSET(value) \ 5466 if ((value) != charoffset) \ 5467 { \ 5468 if ((value) < charoffset) \ 5469 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \ 5470 else \ 5471 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \ 5472 } \ 5473 charoffset = (value); 5474 5475 static PCRE2_SPTR compile_char1_matchingpath(compiler_common *common, PCRE2_UCHAR type, PCRE2_SPTR cc, jump_list **backtracks, BOOL check_str_ptr); 5476 5477 static void compile_xclass_matchingpath(compiler_common *common, PCRE2_SPTR cc, jump_list **backtracks) 5478 { 5479 DEFINE_COMPILER; 5480 jump_list *found = NULL; 5481 jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks; 5482 sljit_uw c, charoffset, max = 256, min = READ_CHAR_MAX; 5483 struct sljit_jump *jump = NULL; 5484 PCRE2_SPTR ccbegin; 5485 int compares, invertcmp, numberofcmps; 5486 #if defined SUPPORT_UNICODE && (PCRE2_CODE_UNIT_WIDTH == 8 || PCRE2_CODE_UNIT_WIDTH == 16) 5487 BOOL utf = common->utf; 5488 #endif 5489 5490 #ifdef SUPPORT_UNICODE 5491 BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE; 5492 BOOL charsaved = FALSE; 5493 int typereg = TMP1; 5494 const sljit_u32 *other_cases; 5495 sljit_uw typeoffset; 5496 #endif 5497 5498 /* Scanning the necessary info. */ 5499 cc++; 5500 ccbegin = cc; 5501 compares = 0; 5502 5503 if (cc[-1] & XCL_MAP) 5504 { 5505 min = 0; 5506 cc += 32 / sizeof(PCRE2_UCHAR); 5507 } 5508 5509 while (*cc != XCL_END) 5510 { 5511 compares++; 5512 if (*cc == XCL_SINGLE) 5513 { 5514 cc ++; 5515 GETCHARINCTEST(c, cc); 5516 if (c > max) max = c; 5517 if (c < min) min = c; 5518 #ifdef SUPPORT_UNICODE 5519 needschar = TRUE; 5520 #endif 5521 } 5522 else if (*cc == XCL_RANGE) 5523 { 5524 cc ++; 5525 GETCHARINCTEST(c, cc); 5526 if (c < min) min = c; 5527 GETCHARINCTEST(c, cc); 5528 if (c > max) max = c; 5529 #ifdef SUPPORT_UNICODE 5530 needschar = TRUE; 5531 #endif 5532 } 5533 #ifdef SUPPORT_UNICODE 5534 else 5535 { 5536 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP); 5537 cc++; 5538 if (*cc == PT_CLIST) 5539 { 5540 other_cases = PRIV(ucd_caseless_sets) + cc[1]; 5541 while (*other_cases != NOTACHAR) 5542 { 5543 if (*other_cases > max) max = *other_cases; 5544 if (*other_cases < min) min = *other_cases; 5545 other_cases++; 5546 } 5547 } 5548 else 5549 { 5550 max = READ_CHAR_MAX; 5551 min = 0; 5552 } 5553 5554 switch(*cc) 5555 { 5556 case PT_ANY: 5557 /* Any either accepts everything or ignored. */ 5558 if (cc[-1] == XCL_PROP) 5559 { 5560 compile_char1_matchingpath(common, OP_ALLANY, cc, backtracks, FALSE); 5561 if (list == backtracks) 5562 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 5563 return; 5564 } 5565 break; 5566 5567 case PT_LAMP: 5568 case PT_GC: 5569 case PT_PC: 5570 case PT_ALNUM: 5571 needstype = TRUE; 5572 break; 5573 5574 case PT_SC: 5575 needsscript = TRUE; 5576 break; 5577 5578 case PT_SPACE: 5579 case PT_PXSPACE: 5580 case PT_WORD: 5581 case PT_PXGRAPH: 5582 case PT_PXPRINT: 5583 case PT_PXPUNCT: 5584 needstype = TRUE; 5585 needschar = TRUE; 5586 break; 5587 5588 case PT_CLIST: 5589 case PT_UCNC: 5590 needschar = TRUE; 5591 break; 5592 5593 default: 5594 SLJIT_ASSERT_STOP(); 5595 break; 5596 } 5597 cc += 2; 5598 } 5599 #endif 5600 } 5601 SLJIT_ASSERT(compares > 0); 5602 5603 /* We are not necessary in utf mode even in 8 bit mode. */ 5604 cc = ccbegin; 5605 read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0); 5606 5607 if ((cc[-1] & XCL_HASPROP) == 0) 5608 { 5609 if ((cc[-1] & XCL_MAP) != 0) 5610 { 5611 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 5612 if (!check_class_ranges(common, (const sljit_u8 *)cc, (((const sljit_u8 *)cc)[31] & 0x80) != 0, TRUE, &found)) 5613 { 5614 OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7); 5615 OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3); 5616 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc); 5617 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0); 5618 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0); 5619 add_jump(compiler, &found, JUMP(SLJIT_NOT_ZERO)); 5620 } 5621 5622 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 5623 JUMPHERE(jump); 5624 5625 cc += 32 / sizeof(PCRE2_UCHAR); 5626 } 5627 else 5628 { 5629 OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, min); 5630 add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min)); 5631 } 5632 } 5633 else if ((cc[-1] & XCL_MAP) != 0) 5634 { 5635 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); 5636 #ifdef SUPPORT_UNICODE 5637 charsaved = TRUE; 5638 #endif 5639 if (!check_class_ranges(common, (const sljit_u8 *)cc, FALSE, TRUE, list)) 5640 { 5641 #if PCRE2_CODE_UNIT_WIDTH == 8 5642 jump = NULL; 5643 if (common->utf) 5644 #endif 5645 jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255); 5646 5647 OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7); 5648 OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3); 5649 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc); 5650 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0); 5651 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0); 5652 add_jump(compiler, list, JUMP(SLJIT_NOT_ZERO)); 5653 5654 #if PCRE2_CODE_UNIT_WIDTH == 8 5655 if (common->utf) 5656 #endif 5657 JUMPHERE(jump); 5658 } 5659 5660 OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0); 5661 cc += 32 / sizeof(PCRE2_UCHAR); 5662 } 5663 5664 #ifdef SUPPORT_UNICODE 5665 if (needstype || needsscript) 5666 { 5667 if (needschar && !charsaved) 5668 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); 5669 5670 OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT); 5671 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1)); 5672 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK); 5673 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT); 5674 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0); 5675 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2)); 5676 OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1); 5677 5678 /* Before anything else, we deal with scripts. */ 5679 if (needsscript) 5680 { 5681 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script)); 5682 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3); 5683 5684 ccbegin = cc; 5685 5686 while (*cc != XCL_END) 5687 { 5688 if (*cc == XCL_SINGLE) 5689 { 5690 cc ++; 5691 GETCHARINCTEST(c, cc); 5692 } 5693 else if (*cc == XCL_RANGE) 5694 { 5695 cc ++; 5696 GETCHARINCTEST(c, cc); 5697 GETCHARINCTEST(c, cc); 5698 } 5699 else 5700 { 5701 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP); 5702 cc++; 5703 if (*cc == PT_SC) 5704 { 5705 compares--; 5706 invertcmp = (compares == 0 && list != backtracks); 5707 if (cc[-1] == XCL_NOTPROP) 5708 invertcmp ^= 0x1; 5709 jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (int)cc[1]); 5710 add_jump(compiler, compares > 0 ? list : backtracks, jump); 5711 } 5712 cc += 2; 5713 } 5714 } 5715 5716 cc = ccbegin; 5717 } 5718 5719 if (needschar) 5720 { 5721 OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0); 5722 } 5723 5724 if (needstype) 5725 { 5726 if (!needschar) 5727 { 5728 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype)); 5729 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3); 5730 } 5731 else 5732 { 5733 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3); 5734 OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype)); 5735 typereg = RETURN_ADDR; 5736 } 5737 } 5738 } 5739 #endif 5740 5741 /* Generating code. */ 5742 charoffset = 0; 5743 numberofcmps = 0; 5744 #ifdef SUPPORT_UNICODE 5745 typeoffset = 0; 5746 #endif 5747 5748 while (*cc != XCL_END) 5749 { 5750 compares--; 5751 invertcmp = (compares == 0 && list != backtracks); 5752 jump = NULL; 5753 5754 if (*cc == XCL_SINGLE) 5755 { 5756 cc ++; 5757 GETCHARINCTEST(c, cc); 5758 5759 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE)) 5760 { 5761 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5762 OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_EQUAL); 5763 numberofcmps++; 5764 } 5765 else if (numberofcmps > 0) 5766 { 5767 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5768 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5769 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5770 numberofcmps = 0; 5771 } 5772 else 5773 { 5774 jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5775 numberofcmps = 0; 5776 } 5777 } 5778 else if (*cc == XCL_RANGE) 5779 { 5780 cc ++; 5781 GETCHARINCTEST(c, cc); 5782 SET_CHAR_OFFSET(c); 5783 GETCHARINCTEST(c, cc); 5784 5785 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE)) 5786 { 5787 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5788 OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL); 5789 numberofcmps++; 5790 } 5791 else if (numberofcmps > 0) 5792 { 5793 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5794 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 5795 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5796 numberofcmps = 0; 5797 } 5798 else 5799 { 5800 jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset)); 5801 numberofcmps = 0; 5802 } 5803 } 5804 #ifdef SUPPORT_UNICODE 5805 else 5806 { 5807 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP); 5808 if (*cc == XCL_NOTPROP) 5809 invertcmp ^= 0x1; 5810 cc++; 5811 switch(*cc) 5812 { 5813 case PT_ANY: 5814 if (!invertcmp) 5815 jump = JUMP(SLJIT_JUMP); 5816 break; 5817 5818 case PT_LAMP: 5819 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset); 5820 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5821 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset); 5822 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5823 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset); 5824 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5825 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5826 break; 5827 5828 case PT_GC: 5829 c = PRIV(ucp_typerange)[(int)cc[1] * 2]; 5830 SET_TYPE_OFFSET(c); 5831 jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c); 5832 break; 5833 5834 case PT_PC: 5835 jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset); 5836 break; 5837 5838 case PT_SC: 5839 compares++; 5840 /* Do nothing. */ 5841 break; 5842 5843 case PT_SPACE: 5844 case PT_PXSPACE: 5845 SET_CHAR_OFFSET(9); 5846 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9); 5847 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5848 5849 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9); 5850 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5851 5852 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9); 5853 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5854 5855 SET_TYPE_OFFSET(ucp_Zl); 5856 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl); 5857 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 5858 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5859 break; 5860 5861 case PT_WORD: 5862 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_UNDERSCORE - charoffset)); 5863 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5864 /* Fall through. */ 5865 5866 case PT_ALNUM: 5867 SET_TYPE_OFFSET(ucp_Ll); 5868 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll); 5869 OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL); 5870 SET_TYPE_OFFSET(ucp_Nd); 5871 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd); 5872 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 5873 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5874 break; 5875 5876 case PT_CLIST: 5877 other_cases = PRIV(ucd_caseless_sets) + cc[1]; 5878 5879 /* At least three characters are required. 5880 Otherwise this case would be handled by the normal code path. */ 5881 SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR); 5882 SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]); 5883 5884 /* Optimizing character pairs, if their difference is power of 2. */ 5885 if (is_powerof2(other_cases[1] ^ other_cases[0])) 5886 { 5887 if (charoffset == 0) 5888 OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]); 5889 else 5890 { 5891 OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset); 5892 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]); 5893 } 5894 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]); 5895 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5896 other_cases += 2; 5897 } 5898 else if (is_powerof2(other_cases[2] ^ other_cases[1])) 5899 { 5900 if (charoffset == 0) 5901 OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]); 5902 else 5903 { 5904 OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset); 5905 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]); 5906 } 5907 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]); 5908 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5909 5910 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(other_cases[0] - charoffset)); 5911 OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5912 5913 other_cases += 3; 5914 } 5915 else 5916 { 5917 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset)); 5918 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5919 } 5920 5921 while (*other_cases != NOTACHAR) 5922 { 5923 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset)); 5924 OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5925 } 5926 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5927 break; 5928 5929 case PT_UCNC: 5930 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_DOLLAR_SIGN - charoffset)); 5931 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 5932 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_COMMERCIAL_AT - charoffset)); 5933 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5934 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_GRAVE_ACCENT - charoffset)); 5935 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5936 5937 SET_CHAR_OFFSET(0xa0); 5938 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(0xd7ff - charoffset)); 5939 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 5940 SET_CHAR_OFFSET(0); 5941 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0); 5942 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_GREATER_EQUAL); 5943 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 5944 break; 5945 5946 case PT_PXGRAPH: 5947 /* C and Z groups are the farthest two groups. */ 5948 SET_TYPE_OFFSET(ucp_Ll); 5949 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll); 5950 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER); 5951 5952 jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll); 5953 5954 /* In case of ucp_Cf, we overwrite the result. */ 5955 SET_CHAR_OFFSET(0x2066); 5956 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066); 5957 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5958 5959 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066); 5960 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5961 5962 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066); 5963 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5964 5965 JUMPHERE(jump); 5966 jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0); 5967 break; 5968 5969 case PT_PXPRINT: 5970 /* C and Z groups are the farthest two groups. */ 5971 SET_TYPE_OFFSET(ucp_Ll); 5972 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll); 5973 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER); 5974 5975 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll); 5976 OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_NOT_EQUAL); 5977 5978 jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll); 5979 5980 /* In case of ucp_Cf, we overwrite the result. */ 5981 SET_CHAR_OFFSET(0x2066); 5982 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066); 5983 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5984 5985 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066); 5986 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL); 5987 5988 JUMPHERE(jump); 5989 jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0); 5990 break; 5991 5992 case PT_PXPUNCT: 5993 SET_TYPE_OFFSET(ucp_Sc); 5994 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc); 5995 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL); 5996 5997 SET_CHAR_OFFSET(0); 5998 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x7f); 5999 OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 6000 6001 SET_TYPE_OFFSET(ucp_Pc); 6002 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc); 6003 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL); 6004 jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp); 6005 break; 6006 6007 default: 6008 SLJIT_ASSERT_STOP(); 6009 break; 6010 } 6011 cc += 2; 6012 } 6013 #endif 6014 6015 if (jump != NULL) 6016 add_jump(compiler, compares > 0 ? list : backtracks, jump); 6017 } 6018 6019 if (found != NULL) 6020 set_jumps(found, LABEL()); 6021 } 6022 6023 #undef SET_TYPE_OFFSET 6024 #undef SET_CHAR_OFFSET 6025 6026 #endif 6027 6028 static PCRE2_SPTR compile_simple_assertion_matchingpath(compiler_common *common, PCRE2_UCHAR type, PCRE2_SPTR cc, jump_list **backtracks) 6029 { 6030 DEFINE_COMPILER; 6031 int length; 6032 struct sljit_jump *jump[4]; 6033 #ifdef SUPPORT_UNICODE 6034 struct sljit_label *label; 6035 #endif /* SUPPORT_UNICODE */ 6036 6037 switch(type) 6038 { 6039 case OP_SOD: 6040 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 6041 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin)); 6042 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0)); 6043 return cc; 6044 6045 case OP_SOM: 6046 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0); 6047 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); 6048 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0)); 6049 return cc; 6050 6051 case OP_NOT_WORD_BOUNDARY: 6052 case OP_WORD_BOUNDARY: 6053 add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL)); 6054 add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_NOT_ZERO : SLJIT_ZERO)); 6055 return cc; 6056 6057 case OP_EODN: 6058 /* Requires rather complex checks. */ 6059 jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0); 6060 if (common->nltype == NLTYPE_FIXED && common->newline > 255) 6061 { 6062 OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 6063 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 6064 if (common->mode == PCRE2_JIT_COMPLETE) 6065 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0)); 6066 else 6067 { 6068 jump[1] = CMP(SLJIT_EQUAL, TMP2, 0, STR_END, 0); 6069 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0); 6070 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS); 6071 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff); 6072 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_NOT_EQUAL); 6073 add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL)); 6074 check_partial(common, TRUE); 6075 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 6076 JUMPHERE(jump[1]); 6077 } 6078 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 6079 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff)); 6080 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff)); 6081 } 6082 else if (common->nltype == NLTYPE_FIXED) 6083 { 6084 OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 6085 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 6086 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0)); 6087 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline)); 6088 } 6089 else 6090 { 6091 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 6092 jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR); 6093 OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 6094 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0); 6095 jump[2] = JUMP(SLJIT_GREATER); 6096 add_jump(compiler, backtracks, JUMP(SLJIT_LESS)); 6097 /* Equal. */ 6098 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 6099 jump[3] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL); 6100 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 6101 6102 JUMPHERE(jump[1]); 6103 if (common->nltype == NLTYPE_ANYCRLF) 6104 { 6105 OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); 6106 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, STR_END, 0)); 6107 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL)); 6108 } 6109 else 6110 { 6111 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STR_PTR, 0); 6112 read_char_range(common, common->nlmin, common->nlmax, TRUE); 6113 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, STR_END, 0)); 6114 add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL)); 6115 add_jump(compiler, backtracks, JUMP(SLJIT_ZERO)); 6116 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1); 6117 } 6118 JUMPHERE(jump[2]); 6119 JUMPHERE(jump[3]); 6120 } 6121 JUMPHERE(jump[0]); 6122 check_partial(common, FALSE); 6123 return cc; 6124 6125 case OP_EOD: 6126 add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0)); 6127 check_partial(common, FALSE); 6128 return cc; 6129 6130 case OP_DOLL: 6131 OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0); 6132 OP2(SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, options), SLJIT_IMM, PCRE2_NOTEOL); 6133 add_jump(compiler, backtracks, JUMP(SLJIT_NOT_ZERO)); 6134 6135 if (!common->endonly) 6136 compile_simple_assertion_matchingpath(common, OP_EODN, cc, backtracks); 6137 else 6138 { 6139 add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0)); 6140 check_partial(common, FALSE); 6141 } 6142 return cc; 6143 6144 case OP_DOLLM: 6145 jump[1] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0); 6146 OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0); 6147 OP2(SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, options), SLJIT_IMM, PCRE2_NOTEOL); 6148 add_jump(compiler, backtracks, JUMP(SLJIT_NOT_ZERO)); 6149 check_partial(common, FALSE); 6150 jump[0] = JUMP(SLJIT_JUMP); 6151 JUMPHERE(jump[1]); 6152 6153 if (common->nltype == NLTYPE_FIXED && common->newline > 255) 6154 { 6155 OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 6156 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); 6157 if (common->mode == PCRE2_JIT_COMPLETE) 6158 add_jump(compiler, backtracks, CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0)); 6159 else 6160 { 6161 jump[1] = CMP(SLJIT_LESS_EQUAL, TMP2, 0, STR_END, 0); 6162 /* STR_PTR = STR_END - IN_UCHARS(1) */ 6163 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff)); 6164 check_partial(common, TRUE); 6165 add_jump(compiler, backtracks, JUMP(SLJIT_JUMP)); 6166 JUMPHERE(jump[1]); 6167 } 6168 6169 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); 6170 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff)); 6171 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff)); 6172 } 6173 else 6174 { 6175 peek_char(common, common->nlmax); 6176 check_newlinechar(common, common->nltype, backtracks, FALSE); 6177 } 6178 JUMPHERE(jump[0]); 6179 return cc; 6180 6181 case OP_CIRC: 6182 OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0); 6183 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin)); 6184 add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0)); 6185 OP2(SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, options), SLJIT_IMM, PCRE2_NOTBOL); 6186 add_jump(compiler, backtracks, JUMP(SLJIT_NOT_ZERO)); 6187 return cc; 6188 6189 case OP_CIRCM: 6190 OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0); 6191 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin)); 6192 jump[1] = CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0); 6193 OP2(SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, options), SLJIT_IMM, PCRE2_NOTBOL); 6194 add_jump(compiler, backtracks, JUMP(SLJIT_NOT_ZERO)); 6195 jump[0] = JUMP(SLJIT_JUMP); 6196 JUMPHERE(jump[1]); 6197 6198 if (!common->alt_circumflex) 6199 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0)); 6200 6201 if (common->nltype == NLTYPE_FIXED && common->newline > 255) 6202 { 6203 OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); 6204 add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, TMP1, 0)); 6205 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2)); 6206 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1)); 6207 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff)); 6208 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff)); 6209 } 6210 else 6211 { 6212 skip_char_back(common); 6213 read_char_range(common, common->nlmin, common->nlmax, TRUE); 6214 check_newlinechar(common, common->nltype, backtracks, FALSE); 6215 } 6216 JUMPHERE(jump[0]); 6217 return cc; 6218 6219 case OP_REVERSE: 6220 length = GET(cc, 0); 6221 if (length == 0) 6222 return cc + LINK_SIZE; 6223 <