pcre_jit_compile.c

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