/[pcre]/code/trunk/pcre_jit_compile.c

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 850 by zherczeg,
Wed Jan  4 17:29:11 2012 UTC
+revision 970 by zherczeg,
Sun May 27 05:28:19 2012 UTC
 Line 82 
 The code generator follows the recursive
  expressions. The basic blocks of regular expressions are condition checkers
  whose execute different commands depending on the result of the condition check.
  The relationship between the operators can be horizontal (concatenation) and
- vertical (sub-expression) (See struct fallback_common for more details).
+ vertical (sub-expression) (See struct backtrack_common for more details).
    'ab' - 'a' and 'b' regexps are concatenated
    'a+' - 'a' is the sub-expression of the '+' operator
  The condition checkers are boolean (true/false) checkers. Machine code is generated
  for the checker itself and for the actions depending on the result of the checker.
- The 'true' case is called as the hot path (expected path), and the other is called as
+ The 'true' case is called as the try path (expected path), and the other is called as
- the 'fallback' path. Branch instructions are expesive for all CPUs, so we avoid taken
+ the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
- branches on the hot path.
+ branches on the try path.
   Greedy star operator (*) :
-    Hot path: match happens.
+    Try path: match happens.
-    Fallback path: match failed.
+    Backtrack path: match failed.
   Non-greedy star operator (*?) :
-    Hot path: no need to perform a match.
+    Try path: no need to perform a match.
-    Fallback path: match is required.
+    Backtrack path: match is required.
  The following example shows how the code generated for a capturing bracket
  with two alternatives. Let A, B, C, D are arbirary regular expressions, and
 Line 108 
 we have the following regular expression
  The generated code will be the following:
-  A hot path
+  A try path
-  '(' hot path (pushing arguments to the stack)
+  '(' try path (pushing arguments to the stack)
-  B hot path
+  B try path
-  ')' hot path (pushing arguments to the stack)
+  ')' try path (pushing arguments to the stack)
-  D hot path
+  D try path
   return with successful match
-  D fallback path
+  D backtrack path
-  ')' fallback path (If we arrived from "C" jump to the fallback of "C")
+  ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
-  B fallback path
+  B backtrack path
   C expected path
-  jump to D hot path
+  jump to D try path
-  C fallback path
+  C backtrack path
-  A fallback path
+  A backtrack path
-  Notice, that the order of fallback code paths are the opposite of the fast
+  Notice, that the order of backtrack code paths are the opposite of the fast
   code paths. In this way the topmost value on the stack is always belong
-  to the current fallback code path. The fallback code path must check
+  to the current backtrack code path. The backtrack path must check
   whether there is a next alternative. If so, it needs to jump back to
-  the hot path eventually. Otherwise it needs to clear out its own stack
+  the try path eventually. Otherwise it needs to clear out its own stack
-  frame and continue the execution on the fallback code paths.
+  frame and continue the execution on the backtrack code paths.
  */
  /*
  Saved stack frames:
  Atomic blocks and asserts require reloading the values of local variables
- when the fallback mechanism performed. Because of OP_RECURSE, the locals
+ when the backtrack mechanism performed. Because of OP_RECURSE, the locals
  are not necessarly known in compile time, thus we need a dynamic restore
  mechanism.
 Line 152 
 typedef struct jit_arguments {
    const pcre_uchar *begin;
    const pcre_uchar *end;
    int *offsets;
-   pcre_uchar *ptr;
+   pcre_uchar *uchar_ptr;
+   pcre_uchar *mark_ptr;
    /* Everything else after. */
    int offsetcount;
    int calllimit;
-Line 162 
 typedef struct jit_arguments {
+Line 163 
 typedef struct jit_arguments {
    pcre_uint8 notempty_atstart;
  } jit_arguments;
- typedef struct executable_function {
+ typedef struct executable_functions {
-   void *executable_func;
+   void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
-   pcre_jit_callback callback;
+   PUBL(jit_callback) callback;
    void *userdata;
-   sljit_uw executable_size;
+   sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
- } executable_function;
+ } executable_functions;
  typedef struct jump_list {
    struct sljit_jump *jump;
-Line 187 
 typedef struct stub_list {
+Line 188 
 typedef struct stub_list {
  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
  /* The following structure is the key data type for the recursive
- code generator. It is allocated by compile_hotpath, and contains
+ code generator. It is allocated by compile_trypath, and contains
- the aguments for compile_fallbackpath. Must be the first member
+ the aguments for compile_backtrackpath. Must be the first member
  of its descendants. */
- typedef struct fallback_common {
+ typedef struct backtrack_common {
    /* Concatenation stack. */
-   struct fallback_common *prev;
+   struct backtrack_common *prev;
-   jump_list *nextfallbacks;
+   jump_list *nextbacktracks;
    /* Internal stack (for component operators). */
-   struct fallback_common *top;
+   struct backtrack_common *top;
-   jump_list *topfallbacks;
+   jump_list *topbacktracks;
    /* Opcode pointer. */
    pcre_uchar *cc;
- } fallback_common;
+ } backtrack_common;
- typedef struct assert_fallback {
+ typedef struct assert_backtrack {
-   fallback_common common;
+   backtrack_common common;
    jump_list *condfailed;
    /* Less than 0 (-1) if a frame is not needed. */
    int framesize;
    /* Points to our private memory word on the stack. */
    int localptr;
    /* For iterators. */
-   struct sljit_label *hotpath;
+   struct sljit_label *trypath;
- } assert_fallback;
+ } assert_backtrack;
- typedef struct bracket_fallback {
+ typedef struct bracket_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Where to coninue if an alternative is successfully matched. */
-   struct sljit_label *althotpath;
+   struct sljit_label *alttrypath;
    /* For rmin and rmax iterators. */
-   struct sljit_label *recursivehotpath;
+   struct sljit_label *recursivetrypath;
    /* For greedy ? operator. */
-   struct sljit_label *zerohotpath;
+   struct sljit_label *zerotrypath;
    /* Contains the branches of a failed condition. */
    union {
      /* Both for OP_COND, OP_SCOND. */
      jump_list *condfailed;
-     assert_fallback *assert;
+     assert_backtrack *assert;
      /* For OP_ONCE. -1 if not needed. */
      int framesize;
    } u;
    /* Points to our private memory word on the stack. */
    int localptr;
- } bracket_fallback;
+ } bracket_backtrack;
- typedef struct bracketpos_fallback {
+ typedef struct bracketpos_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Points to our private memory word on the stack. */
    int localptr;
    /* Reverting stack is needed. */
    int framesize;
    /* Allocated stack size. */
    int stacksize;
- } bracketpos_fallback;
+ } bracketpos_backtrack;
- typedef struct braminzero_fallback {
+ typedef struct braminzero_backtrack {
-   fallback_common common;
+   backtrack_common common;
-   struct sljit_label *hotpath;
+   struct sljit_label *trypath;
- } braminzero_fallback;
+ } braminzero_backtrack;
- typedef struct iterator_fallback {
+ typedef struct iterator_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Next iteration. */
-   struct sljit_label *hotpath;
+   struct sljit_label *trypath;
- } iterator_fallback;
+ } iterator_backtrack;
  typedef struct recurse_entry {
    struct recurse_entry *next;
-Line 263 
 typedef struct recurse_entry {
+Line 264 
 typedef struct recurse_entry {
    int start;
  } recurse_entry;
- typedef struct recurse_fallback {
+ typedef struct recurse_backtrack {
-   fallback_common common;
+   backtrack_common common;
- } recurse_fallback;
+ } recurse_backtrack;
  typedef struct compiler_common {
    struct sljit_compiler *compiler;
    pcre_uchar *start;
-   int localsize;
+   /* Opcode local area direct map. */
    int *localptrs;
+   int cbraptr;
+   /* OVector starting point. Must be divisible by 2. */
+   int ovector_start;
+   /* Last known position of the requested byte. */
+   int req_char_ptr;
+   /* Head of the last recursion. */
+   int recursive_head;
+   /* First inspected character for partial matching. */
+   int start_used_ptr;
+   /* Starting pointer for partial soft matches. */
+   int hit_start;
+   /* End pointer of the first line. */
+   int first_line_end;
+   /* Points to the marked string. */
+   int mark_ptr;
+   /* Other  */
    const pcre_uint8 *fcc;
    sljit_w lcc;
-   int cbraptr;
+   int mode;
    int nltype;
    int newline;
    int bsr_nltype;
    int endonly;
+   BOOL has_set_som;
    sljit_w ctypes;
    sljit_uw name_table;
    sljit_w name_count;
    sljit_w name_entry_size;
+   /* Labels and jump lists. */
+   struct sljit_label *partialmatchlabel;
+   struct sljit_label *leavelabel;
    struct sljit_label *acceptlabel;
    stub_list *stubs;
    recurse_entry *entries;
    recurse_entry *currententry;
+   jump_list *partialmatch;
+   jump_list *leave;
    jump_list *accept;
    jump_list *calllimit;
    jump_list *stackalloc;
-Line 349 
 typedef struct compare_context {
+Line 375 
 typedef struct compare_context {
  enum {
    frame_end = 0,
-   frame_setstrbegin = -1
+   frame_setstrbegin = -1,
+   frame_setmark = -2
  };
+ /* Undefine sljit macros. */
+ #undef CMP
  /* Used for accessing the elements of the stack. */
  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_w))
  #define TMP1          SLJIT_TEMPORARY_REG1
  #define TMP2          SLJIT_TEMPORARY_REG3
  #define TMP3          SLJIT_TEMPORARY_EREG2
- #define STR_PTR       SLJIT_GENERAL_REG1
+ #define STR_PTR       SLJIT_SAVED_REG1
- #define STR_END       SLJIT_GENERAL_REG2
+ #define STR_END       SLJIT_SAVED_REG2
  #define STACK_TOP     SLJIT_TEMPORARY_REG2
- #define STACK_LIMIT   SLJIT_GENERAL_REG3
+ #define STACK_LIMIT   SLJIT_SAVED_REG3
- #define ARGUMENTS     SLJIT_GENERAL_EREG1
+ #define ARGUMENTS     SLJIT_SAVED_EREG1
- #define CALL_COUNT    SLJIT_GENERAL_EREG2
+ #define CALL_COUNT    SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
  /* Locals layout. */
-Line 373 
 enum {
+Line 403 
 enum {
  /* Two local variables for possessive quantifiers (char1 cannot use them). */
  #define POSSESSIVE0      (2 * sizeof(sljit_w))
  #define POSSESSIVE1      (3 * sizeof(sljit_w))
- /* Head of the last recursion. */
- #define RECURSIVE_HEAD   (4 * sizeof(sljit_w))
  /* Max limit of recursions. */
- #define CALL_LIMIT       (5 * sizeof(sljit_w))
+ #define CALL_LIMIT       (4 * sizeof(sljit_w))
- /* Last known position of the requested byte. */
- #define REQ_CHAR_PTR     (6 * sizeof(sljit_w))
- /* End pointer of the first line. */
- #define FIRSTLINE_END    (7 * sizeof(sljit_w))
  /* The output vector is stored on the stack, and contains pointers
  to characters. The vector data is divided into two groups: the first
  group contains the start / end character pointers, and the second is
  the start pointers when the end of the capturing group has not yet reached. */
- #define OVECTOR_START    (8 * sizeof(sljit_w))
+ #define OVECTOR_START    (common->ovector_start)
  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_w))
  #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_w))
  #define PRIV_DATA(cc)    (common->localptrs[(cc) - common->start])
-Line 423 
 the start pointers when the end of the c
+Line 447 
 the start pointers when the end of the c
    sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
  #define COND_VALUE(op, dst, dstw, type) \
    sljit_emit_cond_value(compiler, (op), (dst), (dstw), (type))
+ #define GET_LOCAL_BASE(dst, dstw, offset) \
+   sljit_get_local_base(compiler, (dst), (dstw), (offset))
  static pcre_uchar* bracketend(pcre_uchar* cc)
  {
-Line 441 
 return cc;
+Line 467 
 return cc;
   init_frame
   get_localsize
   copy_locals
-  compile_hotpath
+  compile_trypath
-  compile_fallbackpath
+  compile_backtrackpath
  */
  static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
-Line 494 
 switch(*cc)
+Line 520 
 switch(*cc)
    case OP_BRAZERO:
    case OP_BRAMINZERO:
    case OP_BRAPOSZERO:
+   case OP_COMMIT:
    case OP_FAIL:
    case OP_ACCEPT:
    case OP_ASSERT_ACCEPT:
-Line 632 
 switch(*cc)
+Line 659 
 switch(*cc)
    case OP_SCBRAPOS:
    return cc + 1 + LINK_SIZE + IMM2_SIZE;
+   case OP_MARK:
+   return cc + 1 + 2 + cc[1];
    default:
    return NULL;
    }
-Line 646 
 while (cc < ccend)
+Line 676 
 while (cc < ccend)
    {
    switch(*cc)
      {
+     case OP_SET_SOM:
+     common->has_set_som = TRUE;
+     cc += 1;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 674 
 while (cc < ccend)
+Line 709 
 while (cc < ccend)
      cc += 1 + LINK_SIZE;
      break;
+     case OP_RECURSE:
+     /* Set its value only once. */
+     if (common->recursive_head == 0)
+       {
+       common->recursive_head = common->ovector_start;
+       common->ovector_start += sizeof(sljit_w);
+       }
+     cc += 1 + LINK_SIZE;
+     break;
+     case OP_MARK:
+     if (common->mark_ptr == 0)
+       {
+       common->mark_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_w);
+       }
+     cc += 1 + 2 + cc[1];
+     break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-Line 739 
 static int get_framesize(compiler_common
+Line 793 
 static int get_framesize(compiler_common
  pcre_uchar *ccend = bracketend(cc);
  int length = 0;
  BOOL possessive = FALSE;
- BOOL setsom_found = FALSE;
+ BOOL setsom_found = recursive;
+ BOOL setmark_found = recursive;
  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
    {
-Line 753 
 while (cc < ccend)
+Line 808 
 while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
-     case OP_RECURSE:
+     SLJIT_ASSERT(common->has_set_som);
      if (!setsom_found)
        {
        length += 2;
        setsom_found = TRUE;
        }
-     cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
+     cc += 1;
+     break;
+     case OP_MARK:
+     SLJIT_ASSERT(common->mark_ptr != 0);
+     if (!setmark_found)
+       {
+       length += 2;
+       setmark_found = TRUE;
+       }
+     cc += 1 + 2 + cc[1];
+     break;
+     case OP_RECURSE:
+     if (common->has_set_som && !setsom_found)
+       {
+       length += 2;
+       setsom_found = TRUE;
+       }
+     if (common->mark_ptr != 0 && !setmark_found)
+       {
+       length += 2;
+       setmark_found = TRUE;
+       }
+     cc += 1 + LINK_SIZE;
      break;
      case OP_CBRA:
-Line 789 
 static void init_frame(compiler_common *
+Line 868 
 static void init_frame(compiler_common *
  {
  DEFINE_COMPILER;
  pcre_uchar *ccend = bracketend(cc);
- BOOL setsom_found = FALSE;
+ BOOL setsom_found = recursive;
+ BOOL setmark_found = recursive;
  int offset;
  /* >= 1 + shortest item size (2) */
+ SLJIT_UNUSED_ARG(stacktop);
  SLJIT_ASSERT(stackpos >= stacktop + 2);
  stackpos = STACK(stackpos);
-Line 803 
 while (cc < ccend)
+Line 884 
 while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
-     case OP_RECURSE:
+     SLJIT_ASSERT(common->has_set_som);
      if (!setsom_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
-Line 813 
 while (cc < ccend)
+Line 894 
 while (cc < ccend)
        stackpos += (int)sizeof(sljit_w);
        setsom_found = TRUE;
        }
-     cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
+     cc += 1;
+     break;
+     case OP_MARK:
+     SLJIT_ASSERT(common->mark_ptr != 0);
+     if (!setmark_found)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       stackpos += (int)sizeof(sljit_w);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+       stackpos += (int)sizeof(sljit_w);
+       setmark_found = TRUE;
+       }
+     cc += 1 + 2 + cc[1];
+     break;
+     case OP_RECURSE:
+     if (common->has_set_som && !setsom_found)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);
+       stackpos += (int)sizeof(sljit_w);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+       stackpos += (int)sizeof(sljit_w);
+       setsom_found = TRUE;
+       }
+     if (common->mark_ptr != 0 && !setmark_found)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       stackpos += (int)sizeof(sljit_w);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+       stackpos += (int)sizeof(sljit_w);
+       setmark_found = TRUE;
+       }
+     cc += 1 + LINK_SIZE;
      break;
      case OP_CBRA:
-Line 940 
 while (status != end)
+Line 1057 
 while (status != end)
    switch(status)
      {
      case start:
-     SLJIT_ASSERT(save);
+     SLJIT_ASSERT(save && common->recursive_head != 0);
      count = 1;
-     srcw[0] = RECURSIVE_HEAD;
+     srcw[0] = common->recursive_head;
      status = loop;
      break;
-Line 1201 
 struct sljit_label *loop;
+Line 1318 
 struct sljit_label *loop;
  int i;
  /* At this point we can freely use all temporary registers. */
  /* TMP1 returns with begin - 1. */
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
  if (length < 8)
    {
    for (i = 0; i < length; i++)
-Line 1209 
 if (length < 8)
+Line 1326 
 if (length < 8)
    }
  else
    {
-   OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START - sizeof(sljit_w));
+   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, OVECTOR_START - sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);
    loop = LABEL();
    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_w), SLJIT_TEMPORARY_REG1, 0);
-Line 1225 
 struct sljit_label *loop;
+Line 1342 
 struct sljit_label *loop;
  struct sljit_jump *earlyexit;
  /* At this point we can freely use all registers. */
- OP1(SLJIT_MOV, SLJIT_GENERAL_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+ OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, ARGUMENTS, 0);
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
  OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_TEMPORARY_REG3, 0);
  OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);
+ GET_LOCAL_BASE(SLJIT_SAVED_REG1, 0, OVECTOR_START);
  /* Unlikely, but possible */
  earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);
  loop = LABEL();
- OP2(SLJIT_SUB, SLJIT_GENERAL_REG2, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
- OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_GENERAL_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
+ OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
  /* Copy the integer value to the output buffer */
  #ifdef COMPILE_PCRE16
- OP2(SLJIT_ASHR, SLJIT_GENERAL_REG2, 0, SLJIT_GENERAL_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
  #endif
- OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_GENERAL_REG2, 0);
+ OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
  JUMPTO(SLJIT_C_NOT_ZERO, loop);
  JUMPHERE(earlyexit);
-Line 1250 
 JUMPHERE(earlyexit);
+Line 1371 
 JUMPHERE(earlyexit);
  /* Calculate the return value, which is the maximum ovector value. */
  if (topbracket > 1)
    {
-   OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
+   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);
-   /* OVECTOR(0) is never equal to SLJIT_GENERAL_REG3. */
+   /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
    loop = LABEL();
    OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * (sljit_w)sizeof(sljit_w)));
    OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
-   CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_GENERAL_REG3, 0, loop);
+   CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
    }
  else
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
  }
+ static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *leave)
+ {
+ DEFINE_COMPILER;
+ SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);
+ SLJIT_ASSERT(common->start_used_ptr != 0 && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
+ OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ CMPTO(SLJIT_C_LESS, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 2, leave);
+ /* Store match begin and end. */
+ OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
+ OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
+ OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG1, 0);
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), 0, SLJIT_TEMPORARY_REG3, 0);
+ JUMPTO(SLJIT_JUMP, leave);
+ }
+ static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)
+ {
+ /* May destroy TMP1. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   /* The value of -1 must be kept for start_used_ptr! */
+   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, 1);
+   /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
+   is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
+   jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   JUMPHERE(jump);
+   }
+ else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+   {
+   jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   JUMPHERE(jump);
+   }
+ }
  static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc)
  {
  /* Detects if the character has an othercase. */
-Line 1385 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 1561 
 return (bit < 256) ? ((0 << 8) | bit) :
  #endif /* COMPILE_PCRE8 */
  }
- static SLJIT_INLINE void check_input_end(compiler_common *common, jump_list **fallbacks)
+ static void check_partial(compiler_common *common, BOOL force)
+ {
+ /* Checks whether a partial matching is occured. Does not modify registers. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump = NULL;
+ SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);
+ if (common->mode == JIT_COMPILE)
+   return;
+ if (!force)
+   jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+ else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+ else
+   {
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ if (jump != NULL)
+   JUMPHERE(jump);
+ }
+ static struct sljit_jump *check_str_end(compiler_common *common)
  {
+ /* Does not affect registers. Usually used in a tight spot. */
  DEFINE_COMPILER;
- add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+ struct sljit_jump *jump;
+ struct sljit_jump *nohit;
+ struct sljit_jump *return_value;
+ if (common->mode == JIT_COMPILE)
+   return CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   nohit = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+   JUMPHERE(nohit);
+   return_value = JUMP(SLJIT_JUMP);
+   }
+ else
+   {
+   return_value = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ JUMPHERE(jump);
+ return return_value;
+ }
+ static void detect_partial_match(compiler_common *common, jump_list **backtracks)
+ {
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ if (common->mode == JIT_COMPILE)
+   {
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   return;
+   }
+ /* Partial matching mode. */
+ jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+   }
+ else
+   {
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ JUMPHERE(jump);
  }
  static void read_char(compiler_common *common)
-Line 1529 
 if (common->utf)
+Line 1789 
 if (common->utf)
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
- static void check_newlinechar(compiler_common *common, int nltype, jump_list **fallbacks, BOOL jumpiftrue)
+ static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpiftrue)
  {
  /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
  DEFINE_COMPILER;
-Line 1537 
 DEFINE_COMPILER;
+Line 1797 
 DEFINE_COMPILER;
  if (nltype == NLTYPE_ANY)
    {
    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else if (nltype == NLTYPE_ANYCRLF)
    {
-Line 1545 
 else if (nltype == NLTYPE_ANYCRLF)
+Line 1805 
 else if (nltype == NLTYPE_ANYCRLF)
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
    COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
-   add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else
    {
    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
-   add_jump(compiler, fallbacks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+   add_jump(compiler, backtracks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
    }
  }
-Line 1564 
 of the character (>= 0xc0). Return char
+Line 1824 
 of the character (>= 0xc0). Return char
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  /* Searching for the first zero. */
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
-Line 1623 
 DEFINE_COMPILER;
+Line 1883 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_jump *compare;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
-Line 1660 
 of the character (>= 0xd800). Return cha
+Line 1920 
 of the character (>= 0xd800). Return cha
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);
  /* Do nothing, only return. */
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 1697 
 DEFINE_COMPILER;
+Line 1957 
 DEFINE_COMPILER;
  SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(ucd_stage1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
-Line 1733 
 if (!(hascrorlf || firstline) && (common
+Line 1993 
 if (!(hascrorlf || firstline) && (common
  if (firstline)
    {
    /* Search for the end of the first line. */
+   SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_END, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-Line 1745 
 if (firstline)
+Line 2006 
 if (firstline)
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
-     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
      {
      end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
      mainloop = LABEL();
      /* Continual stores does not cause data dependency. */
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      read_char(common);
      check_newlinechar(common, common->nltype, &newline, TRUE);
      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-Line 1839 
 pcre_uchar oc, bit;
+Line 2100 
 pcre_uchar oc, bit;
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
-Line 1917 
 jump_list *newline = NULL;
+Line 2178 
 jump_list *newline = NULL;
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
-Line 2001 
 struct sljit_jump *jump;
+Line 2262 
 struct sljit_jump *jump;
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
-Line 2066 
 struct sljit_jump *foundoc = NULL;
+Line 2327 
 struct sljit_jump *foundoc = NULL;
  struct sljit_jump *notfound;
  pcre_uchar oc, bit;
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR);
+ SLJIT_ASSERT(common->req_char_ptr != 0);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);
  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
  toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);
  alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);
-Line 2111 
 JUMPTO(SLJIT_JUMP, loop);
+Line 2373 
 JUMPTO(SLJIT_JUMP, loop);
  JUMPHERE(found);
  if (foundoc)
    JUMPHERE(foundoc);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, TMP1, 0);
  JUMPHERE(alreadyfound);
  JUMPHERE(toolong);
  return notfound;
-Line 2123 
 DEFINE_COMPILER;
+Line 2385 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *mainloop;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);
+ GET_LOCAL_BASE(TMP3, 0, 0);
  /* Drop frames until we reach STACK_TOP. */
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
  jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
- OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_LOCALS_REG, 0);
+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_w), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_w));
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_w));
-Line 2150 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
+Line 2413 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
  JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
+ if (common->mark_ptr != 0)
+   {
+   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
+   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
+   JUMPTO(SLJIT_JUMP, mainloop);
+   JUMPHERE(jump);
+   }
  /* Unknown command. */
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
  JUMPTO(SLJIT_JUMP, mainloop);
-Line 2158 
 JUMPTO(SLJIT_JUMP, mainloop);
+Line 2432 
 JUMPTO(SLJIT_JUMP, mainloop);
  static void check_wordboundary(compiler_common *common)
  {
  DEFINE_COMPILER;
- struct sljit_jump *beginend;
+ struct sljit_jump *skipread;
  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
  struct sljit_jump *jump;
  #endif
  SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
- sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  /* Get type of the previous char, and put it to LOCALS1. */
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);
- beginend = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+ skipread = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
  skip_char_back(common);
+ check_start_used_ptr(common);
  read_char(common);
  /* Testing char type. */
-Line 2212 
 else
+Line 2487 
 else
      JUMPHERE(jump);
  #endif /* COMPILE_PCRE8 */
    }
- JUMPHERE(beginend);
+ JUMPHERE(skipread);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
- beginend = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ skipread = check_str_end(common);
  peek_char(common);
  /* Testing char type. This is a code duplication. */
-Line 2256 
 else
+Line 2531 
 else
      JUMPHERE(jump);
  #endif /* COMPILE_PCRE8 */
    }
- JUMPHERE(beginend);
+ JUMPHERE(skipread);
  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
-Line 2267 
 static void check_anynewline(compiler_co
+Line 2542 
 static void check_anynewline(compiler_co
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
-Line 2294 
 static void check_hspace(compiler_common
+Line 2569 
 static void check_hspace(compiler_common
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
-Line 2333 
 static void check_vspace(compiler_common
+Line 2608 
 static void check_vspace(compiler_common
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
-Line 2365 
 DEFINE_COMPILER;
+Line 2640 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *label;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);
-Line 2394 
 DEFINE_COMPILER;
+Line 2669 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *label;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
-Line 2441 
 static const pcre_uchar *SLJIT_CALL do_u
+Line 2716 
 static const pcre_uchar *SLJIT_CALL do_u
  {
  /* This function would be ineffective to do in JIT level. */
  int c1, c2;
- const pcre_uchar *src2 = args->ptr;
+ const pcre_uchar *src2 = args->uchar_ptr;
  const pcre_uchar *end2 = args->end;
  while (src1 < end1)
    {
    if (src2 >= end2)
-     return 0;
+     return (pcre_uchar*)1;
    GETCHARINC(c1, src1);
    GETCHARINC(c2, src2);
-   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return 0;
+   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return NULL;
    }
  return src2;
  }
-Line 2458 
 return src2;
+Line 2733 
 return src2;
  #endif /* SUPPORT_UTF && SUPPORT_UCP */
  static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
-     compare_context* context, jump_list **fallbacks)
+     compare_context* context, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  unsigned int othercasebit = 0;
-Line 2559 
 do
+Line 2834 
 do
        case 4 / sizeof(pcre_uchar):
        if (context->oc.asint != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
        break;
        case 2 / sizeof(pcre_uchar):
        if (context->oc.asushort != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
        break;
  #ifdef COMPILE_PCRE8
        case 1:
        if (context->oc.asbyte != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
        break;
  #endif
-Line 2598 
 do
+Line 2873 
 do
    if (othercasebit != 0 && othercasechar == cc)
      {
      OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
      }
    else
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
  #endif
-Line 2637 
 return cc;
+Line 2912 
 return cc;
      } \
    charoffset = (value);
- static void compile_xclass_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
+ static void compile_xclass_trypath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  jump_list *found = NULL;
- jump_list **list = (*cc & XCL_NOT) == 0 ? &found : fallbacks;
+ jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;
  unsigned int c;
  int compares;
  struct sljit_jump *jump = NULL;
-Line 2656 
 int invertcmp, numberofcmps;
+Line 2931 
 int invertcmp, numberofcmps;
  unsigned int charoffset;
  /* Although SUPPORT_UTF must be defined, we are not necessary in utf mode. */
- check_input_end(common, fallbacks);
+ detect_partial_match(common, backtracks);
  read_char(common);
  if ((*cc++ & XCL_MAP) != 0)
-Line 2807 
 typeoffset = 0;
+Line 3082 
 typeoffset = 0;
  while (*cc != XCL_END)
    {
    compares--;
-   invertcmp = (compares == 0 && list != fallbacks);
+   invertcmp = (compares == 0 && list != backtracks);
    jump = NULL;
    if (*cc == XCL_SINGLE)
-Line 2889 
 while (*cc != XCL_END)
+Line 3164 
 while (*cc != XCL_END)
      switch(*cc)
        {
        case PT_ANY:
-       if (list != fallbacks)
+       if (list != backtracks)
          {
          if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))
            continue;
-Line 2962 
 while (*cc != XCL_END)
+Line 3237 
 while (*cc != XCL_END)
  #endif
    if (jump != NULL)
-     add_jump(compiler, compares > 0 ? list : fallbacks, jump);
+     add_jump(compiler, compares > 0 ? list : backtracks, jump);
    }
  if (found != NULL)
-Line 2974 
 if (found != NULL)
+Line 3249 
 if (found != NULL)
  #endif
- static pcre_uchar *compile_char1_hotpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **fallbacks)
+ static pcre_uchar *compile_char1_trypath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  int length;
-Line 2993 
 switch(type)
+Line 3268 
 switch(type)
    case OP_SOD:
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
    return cc;
    case OP_SOM:
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
    return cc;
    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
    add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
    case OP_NOT_DIGIT:
    case OP_DIGIT:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
-   add_jump(compiler, fallbacks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
-   add_jump(compiler, fallbacks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
-   add_jump(compiler, fallbacks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_ANY:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
-     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     if (common->mode != JIT_PARTIAL_HARD_COMPILE)
+       jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     else
+       jump[1] = check_str_end(common);
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
-     JUMPHERE(jump[1]);
+     if (jump[1] != NULL)
+       JUMPHERE(jump[1]);
      JUMPHERE(jump[0]);
      }
    else
-     check_newlinechar(common, common->nltype, fallbacks, TRUE);
+     check_newlinechar(common, common->nltype, backtracks, TRUE);
    return cc;
    case OP_ALLANY:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
  #ifdef SUPPORT_UTF
    if (common->utf)
      {
-Line 3077 
 switch(type)
+Line 3357 
 switch(type)
    return cc;
    case OP_ANYBYTE:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    return cc;
-Line 3090 
 switch(type)
+Line 3370 
 switch(type)
    propdata[2] = cc[0];
    propdata[3] = cc[1];
    propdata[4] = XCL_END;
-   compile_xclass_hotpath(common, propdata, fallbacks);
+   compile_xclass_trypath(common, propdata, backtracks);
    return cc + 2;
  #endif
  #endif
    case OP_ANYNL:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
-   jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   /* We don't need to handle soft partial matching case. */
+   if (common->mode != JIT_PARTIAL_HARD_COMPILE)
+     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   else
+     jump[1] = check_str_end(common);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    jump[3] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[0]);
-   check_newlinechar(common, common->bsr_nltype, fallbacks, FALSE);
+   check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
    JUMPHERE(jump[1]);
    JUMPHERE(jump[2]);
    JUMPHERE(jump[3]);
-Line 3113 
 switch(type)
+Line 3397 
 switch(type)
    case OP_NOT_HSPACE:
    case OP_HSPACE:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
    case OP_NOT_VSPACE:
    case OP_VSPACE:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
  #ifdef SUPPORT_UCP
    case OP_EXTUNI:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
    label = LABEL();
    jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-Line 3145 
 switch(type)
+Line 3429 
 switch(type)
    OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
    JUMPHERE(jump[0]);
+   if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+     {
+     jump[0] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+     /* Since we successfully read a char above, partial matching must occure. */
+     check_partial(common, TRUE);
+     JUMPHERE(jump[0]);
+     }
    return cc;
  #endif
    case OP_EODN:
+   /* Requires rather complex checks. */
    jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     if (common->mode == JIT_COMPILE)
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     else
+       {
+       jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
+       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
+       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_NOT_EQUAL);
+       add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));
+       check_partial(common, TRUE);
+       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+       JUMPHERE(jump[1]);
+       }
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else if (common->nltype == NLTYPE_FIXED)
      {
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
      }
    else
      {
-Line 3173 
 switch(type)
+Line 3478 
 switch(type)
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
      jump[2] = JUMP(SLJIT_C_GREATER);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_C_LESS));
+     add_jump(compiler, backtracks, JUMP(SLJIT_C_LESS));
      /* Equal. */
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
      jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
      JUMPHERE(jump[1]);
      if (common->nltype == NLTYPE_ANYCRLF)
        {
        OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
        }
      else
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);
        read_char(common);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
        add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
-       add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+       add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
        }
      JUMPHERE(jump[2]);
      JUMPHERE(jump[3]);
      }
    JUMPHERE(jump[0]);
+   check_partial(common, FALSE);
    return cc;
    case OP_EOD:
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+   check_partial(common, FALSE);
    return cc;
    case OP_CIRC:
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    return cc;
    case OP_CIRCM:
-Line 3218 
 switch(type)
+Line 3525 
 switch(type)
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
    jump[1] = CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else
      {
      skip_char_back(common);
      read_char(common);
-     check_newlinechar(common, common->nltype, fallbacks, FALSE);
+     check_newlinechar(common, common->nltype, backtracks, FALSE);
      }
    JUMPHERE(jump[0]);
    return cc;
-Line 3244 
 switch(type)
+Line 3551 
 switch(type)
    case OP_DOLL:
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    if (!common->endonly)
-     compile_char1_hotpath(common, OP_EODN, cc, fallbacks);
+     compile_char1_trypath(common, OP_EODN, cc, backtracks);
    else
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+     {
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+     check_partial(common, FALSE);
+     }
    return cc;
    case OP_DOLLM:
    jump[1] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   check_partial(common, FALSE);
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     if (common->mode == JIT_COMPILE)
+       add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
+     else
+       {
+       jump[1] = CMP(SLJIT_C_LESS_EQUAL, TMP2, 0, STR_END, 0);
+       /* STR_PTR = STR_END - IN_UCHARS(1) */
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+       check_partial(common, TRUE);
+       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+       JUMPHERE(jump[1]);
+       }
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else
      {
      peek_char(common);
-     check_newlinechar(common, common->nltype, fallbacks, FALSE);
+     check_newlinechar(common, common->nltype, backtracks, FALSE);
      }
    JUMPHERE(jump[0]);
    return cc;
-Line 3283 
 switch(type)
+Line 3605 
 switch(type)
  #ifdef SUPPORT_UTF
    if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
  #endif
-   if (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0)
+   if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
      {
      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
      context.length = IN_UCHARS(length);
      context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
      context.ucharptr = 0;
  #endif
-     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);
+     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
      }
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3305 
 switch(type)
+Line 3627 
 switch(type)
    else
  #endif
      c = *cc;
+   if (type == OP_CHAR || !char_has_othercase(common, cc))
+     {
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+     return cc + length;
+     }
+   oc = char_othercase(common, c);
+   bit = c ^ oc;
+   if (ispowerof2(bit))
+     {
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+     return cc + length;
+     }
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char_othercase(common, c));
    COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
-   add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
    return cc + length;
    case OP_NOT:
    case OP_NOTI:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    length = 1;
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3325 
 switch(type)
+Line 3660 
 switch(type)
        {
        OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
        if (type == OP_NOT || !char_has_othercase(common, cc))
-         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+         add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
        else
          {
          /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
          OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
-         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
+         add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
          }
        /* Skip the variable-length character. */
        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-Line 3355 
 switch(type)
+Line 3690 
 switch(type)
      }
    if (type == OP_NOT || !char_has_othercase(common, cc))
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
    else
      {
      oc = char_othercase(common, c);
-Line 3363 
 switch(type)
+Line 3698 
 switch(type)
      if (ispowerof2(bit))
        {
        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
        }
      else
        {
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
        }
      }
-   return cc + 1;
+   return cc + length;
    case OP_CLASS:
    case OP_NCLASS:
-   check_input_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    jump[0] = NULL;
-Line 3388 
 switch(type)
+Line 3723 
 switch(type)
      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
      if (type == OP_CLASS)
        {
-       add_jump(compiler, fallbacks, jump[0]);
+       add_jump(compiler, backtracks, jump[0]);
        jump[0] = NULL;
        }
      }
-Line 3398 
 switch(type)
+Line 3733 
 switch(type)
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
-   add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    if (jump[0] != NULL)
      JUMPHERE(jump[0]);
-Line 3407 
 switch(type)
+Line 3742 
 switch(type)
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16
    case OP_XCLASS:
-   compile_xclass_hotpath(common, cc + LINK_SIZE, fallbacks);
+   compile_xclass_trypath(common, cc + LINK_SIZE, backtracks);
    return cc + GET(cc, 0) - 1;
  #endif
    case OP_REVERSE:
    length = GET(cc, 0);
-   SLJIT_ASSERT(length > 0);
+   if (length == 0)
+     return cc + LINK_SIZE;
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3421 
 switch(type)
+Line 3757 
 switch(type)
      OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
      label = LABEL();
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
      skip_char_back(common);
      OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
      JUMPTO(SLJIT_C_NOT_ZERO, label);
-     return cc + LINK_SIZE;
      }
+   else
  #endif
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+     {
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+     OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+     }
+   check_start_used_ptr(common);
    return cc + LINK_SIZE;
    }
  SLJIT_ASSERT_STOP();
  return cc;
  }
- static SLJIT_INLINE pcre_uchar *compile_charn_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **fallbacks)
+ static SLJIT_INLINE pcre_uchar *compile_charn_trypath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)
  {
  /* This function consumes at least one input character. */
  /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
-Line 3489 
 if (context.length > 0)
+Line 3828 
 if (context.length > 0)
    {
    /* We have a fixed-length byte sequence. */
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
    context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    context.ucharptr = 0;
  #endif
-   do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks); while (context.length > 0);
+   do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
    return cc;
    }
  /* A non-fixed length character will be checked if length == 0. */
- return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);
+ return compile_char1_trypath(common, *cc, cc + 1, backtracks);
  }
- static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
+ static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
-Line 3511 
 int offset = GET2(cc, 1) << 1;
+Line 3850 
 int offset = GET2(cc, 1) << 1;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
  if (!common->jscript_compat)
    {
-   if (fallbacks == NULL)
+   if (backtracks == NULL)
      {
+     /* OVECTOR(1) contains the "string begin - 1" constant. */
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
      COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
      COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
      return JUMP(SLJIT_C_NOT_ZERO);
      }
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
    }
  return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
  }
  /* Forward definitions. */
- static void compile_hotpath(compiler_common *, pcre_uchar *, pcre_uchar *, fallback_common *);
+ static void compile_trypath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
- static void compile_fallbackpath(compiler_common *, struct fallback_common *);
+ static void compile_backtrackpath(compiler_common *, struct backtrack_common *);
- #define PUSH_FALLBACK(size, ccstart, error) \
+ #define PUSH_BACKTRACK(size, ccstart, error) \
    do \
      { \
-     fallback = sljit_alloc_memory(compiler, (size)); \
+     backtrack = sljit_alloc_memory(compiler, (size)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return error; \
-     memset(fallback, 0, size); \
+     memset(backtrack, 0, size); \
-     fallback->prev = parent->top; \
+     backtrack->prev = parent->top; \
-     fallback->cc = (ccstart); \
+     backtrack->cc = (ccstart); \
-     parent->top = fallback; \
+     parent->top = backtrack; \
      } \
    while (0)
- #define PUSH_FALLBACK_NOVALUE(size, ccstart) \
+ #define PUSH_BACKTRACK_NOVALUE(size, ccstart) \
    do \
      { \
-     fallback = sljit_alloc_memory(compiler, (size)); \
+     backtrack = sljit_alloc_memory(compiler, (size)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return; \
-     memset(fallback, 0, size); \
+     memset(backtrack, 0, size); \
-     fallback->prev = parent->top; \
+     backtrack->prev = parent->top; \
-     fallback->cc = (ccstart); \
+     backtrack->cc = (ccstart); \
-     parent->top = fallback; \
+     parent->top = backtrack; \
      } \
    while (0)
- #define FALLBACK_AS(type) ((type*)fallback)
+ #define BACKTRACK_AS(type) ((type *)backtrack)
- static pcre_uchar *compile_ref_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail)
+ static pcre_uchar *compile_ref_trypath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
  struct sljit_jump *jump = NULL;
+ struct sljit_jump *partial;
+ struct sljit_jump *nopartial;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
+ /* OVECTOR(1) contains the "string begin - 1" constant. */
  if (withchecks && !common->jscript_compat)
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
  if (common->utf && *cc == OP_REFI)
-Line 3577 
 if (common->utf && *cc == OP_REFI)
+Line 3920 
 if (common->utf && *cc == OP_REFI)
    /* Needed to save important temporary registers. */
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, ptr), STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
    sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+   if (common->mode == JIT_COMPILE)
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
+   else
+     {
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+     nopartial = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
+     check_partial(common, FALSE);
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+     JUMPHERE(nopartial);
+     }
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
    }
  else
-Line 3589 
 else
+Line 3941 
 else
    OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
    if (withchecks)
      jump = JUMP(SLJIT_C_ZERO);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+   partial = CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0);
+   if (common->mode == JIT_COMPILE)
+     add_jump(compiler, backtracks, partial);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
    add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   if (common->mode != JIT_COMPILE)
+     {
+     nopartial = JUMP(SLJIT_JUMP);
+     JUMPHERE(partial);
+     /* TMP2 -= STR_END - STR_PTR */
+     OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);
+     OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);
+     partial = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0);
+     OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
+     add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+     JUMPHERE(partial);
+     check_partial(common, FALSE);
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+     JUMPHERE(nopartial);
+     }
    }
  if (jump != NULL)
    {
    if (emptyfail)
-     add_jump(compiler, fallbacks, jump);
+     add_jump(compiler, backtracks, jump);
    else
      JUMPHERE(jump);
    }
  return cc + 1 + IMM2_SIZE;
  }
- static SLJIT_INLINE pcre_uchar *compile_ref_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_ref_iterator_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar type;
  struct sljit_label *label;
  struct sljit_jump *zerolength;
-Line 3618 
 pcre_uchar *ccbegin = cc;
+Line 3990 
 pcre_uchar *ccbegin = cc;
  int min = 0, max = 0;
  BOOL minimize;
- PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
  type = cc[1 + IMM2_SIZE];
  minimize = (type & 0x1) != 0;
-Line 3670 
 if (!minimize)
+Line 4042 
 if (!minimize)
      {
      allocate_stack(common, 1);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-     zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
+     zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
      }
    if (min > 1 || max > 1)
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
    label = LABEL();
-   compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, FALSE, FALSE);
+   compile_ref_trypath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
    if (min > 1 || max > 1)
      {
-Line 3705 
 if (!minimize)
+Line 4077 
 if (!minimize)
      }
    JUMPHERE(zerolength);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
    decrease_call_count(common);
    return cc;
-Line 3723 
 if (min == 0)
+Line 4095 
 if (min == 0)
    jump = JUMP(SLJIT_JUMP);
    }
  else
-   zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
+   zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
- FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+ BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
  if (max > 0)
-   add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
+   add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
- compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, TRUE, TRUE);
+ compile_ref_trypath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
  if (min > 1)
-Line 3737 
 if (min > 1)
+Line 4109 
 if (min > 1)
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, FALLBACK_AS(iterator_fallback)->hotpath);
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(iterator_backtrack)->trypath);
    }
  else if (max > 0)
    OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
-Line 3750 
 decrease_call_count(common);
+Line 4122 
 decrease_call_count(common);
  return cc;
  }
- static SLJIT_INLINE pcre_uchar *compile_recurse_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_recurse_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  recurse_entry *entry = common->entries;
  recurse_entry *prev = NULL;
  int start = GET(cc, 1);
- PUSH_FALLBACK(sizeof(recurse_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
  while (entry != NULL)
    {
    if (entry->start == start)
-Line 3783 
 if (entry == NULL)
+Line 4155 
 if (entry == NULL)
      common->entries = entry;
    }
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+ if (common->has_set_som && common->mark_ptr != 0)
- allocate_stack(common, 1);
+   {
- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+   allocate_stack(common, 2);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   }
+ else if (common->has_set_som || common->mark_ptr != 0)
+   {
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);
+   allocate_stack(common, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   }
  if (entry->entry == NULL)
    add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));
  else
    JUMPTO(SLJIT_FAST_CALL, entry->entry);
  /* Leave if the match is failed. */
- add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));
+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));
  return cc + 1 + LINK_SIZE;
  }
- static pcre_uchar *compile_assert_hotpath(compiler_common *common, pcre_uchar *cc, assert_fallback *fallback, BOOL conditional)
+ static pcre_uchar *compile_assert_trypath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
  {
  DEFINE_COMPILER;
  int framesize;
  int localptr;
- fallback_common altfallback;
+ backtrack_common altbacktrack;
  pcre_uchar *ccbegin;
  pcre_uchar opcode;
  pcre_uchar bra = OP_BRA;
  jump_list *tmp = NULL;
- jump_list **target = (conditional) ? &fallback->condfailed : &fallback->common.topfallbacks;
+ jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
  jump_list **found;
  /* Saving previous accept variables. */
+ struct sljit_label *save_leavelabel = common->leavelabel;
  struct sljit_label *save_acceptlabel = common->acceptlabel;
+ jump_list *save_leave = common->leave;
+ jump_list *save_accept = common->accept;
  struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
- jump_list *save_accept = common->accept;
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
-Line 3823 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4208 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
  framesize = get_framesize(common, cc, FALSE);
- fallback->framesize = framesize;
+ backtrack->framesize = framesize;
- fallback->localptr = localptr;
+ backtrack->localptr = localptr;
  opcode = *cc;
  SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
  found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
-Line 3833 
 cc += GET(cc, 1);
+Line 4218 
 cc += GET(cc, 1);
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a braminzero fallback path. */
+   /* This is a braminzero backtrack path. */
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    free_stack(common, 1);
    brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
-Line 3856 
 else
+Line 4241 
 else
    init_frame(common, ccbegin, framesize + 1, 2, FALSE);
    }
- memset(&altfallback, 0, sizeof(fallback_common));
+ memset(&altbacktrack, 0, sizeof(backtrack_common));
+ common->leavelabel = NULL;
+ common->leave = NULL;
  while (1)
    {
    common->acceptlabel = NULL;
    common->accept = NULL;
-   altfallback.top = NULL;
+   altbacktrack.top = NULL;
-   altfallback.topfallbacks = NULL;
+   altbacktrack.topbacktracks = NULL;
    if (*ccbegin == OP_ALT)
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   altfallback.cc = ccbegin;
+   altbacktrack.cc = ccbegin;
-   compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);
+   compile_trypath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
+     common->leavelabel = save_leavelabel;
      common->acceptlabel = save_acceptlabel;
+     common->leave = save_leave;
      common->accept = save_accept;
      return NULL;
      }
-Line 3921 
 while (1)
+Line 4310 
 while (1)
      }
    add_jump(compiler, found, JUMP(SLJIT_JUMP));
-   compile_fallbackpath(common, altfallback.top);
+   compile_backtrackpath(common, altbacktrack.top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
+     common->leavelabel = save_leavelabel;
      common->acceptlabel = save_acceptlabel;
+     common->leave = save_leave;
      common->accept = save_accept;
      return NULL;
      }
-   set_jumps(altfallback.topfallbacks, LABEL());
+   set_jumps(altbacktrack.topbacktracks, LABEL());
    if (*cc != OP_ALT)
      break;
-Line 3937 
 while (1)
+Line 4328 
 while (1)
    cc += GET(cc, 1);
    }
  /* None of them matched. */
+ if (common->leave != NULL)
+   set_jumps(common->leave, LABEL());
  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
    {
-Line 4003 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4396 
 if (opcode == OP_ASSERT || opcode == OP_
    if (bra == OP_BRAZERO)
      {
-     fallback->hotpath = LABEL();
+     backtrack->trypath = LABEL();
-     sljit_set_label(jump, fallback->hotpath);
+     sljit_set_label(jump, backtrack->trypath);
      }
    else if (bra == OP_BRAMINZERO)
      {
-     JUMPTO(SLJIT_JUMP, fallback->hotpath);
+     JUMPTO(SLJIT_JUMP, backtrack->trypath);
      JUMPHERE(brajump);
      if (framesize >= 0)
        {
-Line 4016 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4409 
 if (opcode == OP_ASSERT || opcode == OP_
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
        }
-     set_jumps(fallback->common.topfallbacks, LABEL());
+     set_jumps(backtrack->common.topbacktracks, LABEL());
      }
    }
  else
-Line 4046 
 else
+Line 4439 
 else
      }
    if (bra == OP_BRAZERO)
-     fallback->hotpath = LABEL();
+     backtrack->trypath = LABEL();
    else if (bra == OP_BRAMINZERO)
      {
-     JUMPTO(SLJIT_JUMP, fallback->hotpath);
+     JUMPTO(SLJIT_JUMP, backtrack->trypath);
      JUMPHERE(brajump);
      }
    if (bra != OP_BRA)
      {
-     SLJIT_ASSERT(found == &fallback->common.topfallbacks);
+     SLJIT_ASSERT(found == &backtrack->common.topbacktracks);
-     set_jumps(fallback->common.topfallbacks, LABEL());
+     set_jumps(backtrack->common.topbacktracks, LABEL());
-     fallback->common.topfallbacks = NULL;
+     backtrack->common.topbacktracks = NULL;
      }
    }
+ common->leavelabel = save_leavelabel;
  common->acceptlabel = save_acceptlabel;
+ common->leave = save_leave;
  common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
-Line 4076 
 sljit_w name_entry_size = locals[LOCALS1
+Line 4471 
 sljit_w name_entry_size = locals[LOCALS1
  sljit_w no_capture;
  int i;
- locals += OVECTOR_START / sizeof(sljit_w);
+ locals += refno & 0xff;
+ refno >>= 8;
  no_capture = locals[1];
  for (i = 0; i < name_count; i++)
-Line 4229 
 return condition;
+Line 4625 
 return condition;
                                            Or nothing, if trace is unnecessary
  */
- static pcre_uchar *compile_bracket_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracket_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  int localptr = 0;
  int offset = 0;
  int stacksize;
  pcre_uchar *ccbegin;
- pcre_uchar *hotpath;
+ pcre_uchar *trypath;
  pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
- assert_fallback *assert;
+ assert_backtrack *assert;
  BOOL has_alternatives;
  struct sljit_jump *jump;
  struct sljit_jump *skip;
  struct sljit_label *rmaxlabel = NULL;
  struct sljit_jump *braminzerojump = NULL;
- PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
-Line 4259 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4655 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  opcode = *cc;
  ccbegin = cc;
- hotpath = ccbegin + 1 + LINK_SIZE;
+ trypath = ccbegin + 1 + LINK_SIZE;
  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
    {
-   /* Drop this bracket_fallback. */
+   /* Drop this bracket_backtrack. */
-   parent->top = fallback->prev;
+   parent->top = backtrack->prev;
    return bracketend(cc);
    }
-Line 4276 
 cc += GET(cc, 1);
+Line 4672 
 cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
    {
-   has_alternatives = (*hotpath == OP_RREF) ? FALSE : TRUE;
+   has_alternatives = (*trypath == OP_RREF) ? FALSE : TRUE;
-   if (*hotpath == OP_NRREF)
+   if (*trypath == OP_NRREF)
      {
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(trypath, 1);
      if (common->currententry == NULL || stacksize == RREF_ANY)
        has_alternatives = FALSE;
      else if (common->currententry->start == 0)
-Line 4300 
 if (opcode == OP_CBRA || opcode == OP_SC
+Line 4696 
 if (opcode == OP_CBRA || opcode == OP_SC
    offset = GET2(ccbegin, 1 + LINK_SIZE);
    localptr = OVECTOR_PRIV(offset);
    offset <<= 1;
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   BACKTRACK_AS(bracket_backtrack)->localptr = localptr;
-   hotpath += IMM2_SIZE;
+   trypath += IMM2_SIZE;
    }
  else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
    {
    /* Other brackets simply allocate the next entry. */
    localptr = PRIV_DATA(ccbegin);
    SLJIT_ASSERT(localptr != 0);
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   BACKTRACK_AS(bracket_backtrack)->localptr = localptr;
    if (opcode == OP_ONCE)
-     FALLBACK_AS(bracket_fallback)->u.framesize = get_framesize(common, ccbegin, FALSE);
+     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, FALSE);
    }
  /* Instructions before the first alternative. */
-Line 4335 
 if (bra == OP_BRAZERO)
+Line 4731 
 if (bra == OP_BRAZERO)
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a fallback path! (Since the hot-path of OP_BRAMINZERO matches to the empty string) */
+   /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    if (ket != OP_KETRMIN)
      {
-Line 4352 
 if (bra == OP_BRAMINZERO)
+Line 4748 
 if (bra == OP_BRAMINZERO)
        skip = JUMP(SLJIT_JUMP);
        JUMPHERE(jump);
        /* Checking zero-length iteration. */
-       if (opcode != OP_ONCE || FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+       if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
          {
          /* When we come from outside, localptr contains the previous STR_PTR. */
          braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 4361 
 if (bra == OP_BRAMINZERO)
+Line 4757 
 if (bra == OP_BRAMINZERO)
          {
          /* Except when the whole stack frame must be saved. */
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (FALLBACK_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));
+         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_w));
          }
        JUMPHERE(skip);
        }
-Line 4375 
 if (bra == OP_BRAMINZERO)
+Line 4771 
 if (bra == OP_BRAMINZERO)
    }
  if (ket == OP_KETRMIN)
-   FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->recursivetrypath = LABEL();
  if (ket == OP_KETRMAX)
    {
    rmaxlabel = LABEL();
    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)
-     FALLBACK_AS(bracket_fallback)->althotpath = rmaxlabel;
+     BACKTRACK_AS(bracket_backtrack)->alttrypath = rmaxlabel;
    }
  /* Handling capturing brackets and alternatives. */
  if (opcode == OP_ONCE)
    {
-   if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
      {
      /* Neither capturing brackets nor recursions are not found in the block. */
      if (ket == OP_KETRMIN)
-Line 4411 
 if (opcode == OP_ONCE)
+Line 4807 
 if (opcode == OP_ONCE)
      {
      if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)
        {
-       allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 2);
+       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 2);
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize + 1));
+       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize + 1));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
-       init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize + 1, 2, FALSE);
+       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1, 2, FALSE);
        }
      else
        {
-       allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 1);
+       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1);
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize));
+       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
-       init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize, 1, FALSE);
+       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize, 1, FALSE);
        }
      }
    }
-Line 4460 
 else if (has_alternatives)
+Line 4856 
 else if (has_alternatives)
  /* Generating code for the first alternative. */
  if (opcode == OP_COND || opcode == OP_SCOND)
    {
-   if (*hotpath == OP_CREF)
+   if (*trypath == OP_CREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed),
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
-       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(trypath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-     hotpath += 1 + IMM2_SIZE;
+     trypath += 1 + IMM2_SIZE;
      }
-   else if (*hotpath == OP_NCREF)
+   else if (*trypath == OP_NCREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(trypath, 1);
      jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
-     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
+     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_w)));
-     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+     GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
      OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
      sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-     add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
      JUMPHERE(jump);
-     hotpath += 1 + IMM2_SIZE;
+     trypath += 1 + IMM2_SIZE;
      }
-   else if (*hotpath == OP_RREF || *hotpath == OP_NRREF)
+   else if (*trypath == OP_RREF || *trypath == OP_NRREF)
      {
      /* Never has other case. */
-     FALLBACK_AS(bracket_fallback)->u.condfailed = NULL;
+     BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(trypath, 1);
      if (common->currententry == NULL)
        stacksize = 0;
      else if (stacksize == RREF_ANY)
-Line 4501 
 if (opcode == OP_COND || opcode == OP_SC
+Line 4897 
 if (opcode == OP_COND || opcode == OP_SC
      else
        stacksize = stacksize == GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     if (*hotpath == OP_RREF || stacksize || common->currententry == NULL)
+     if (*trypath == OP_RREF || stacksize || common->currententry == NULL)
        {
        SLJIT_ASSERT(!has_alternatives);
        if (stacksize != 0)
-         hotpath += 1 + IMM2_SIZE;
+         trypath += 1 + IMM2_SIZE;
        else
          {
          if (*cc == OP_ALT)
            {
-           hotpath = cc + 1 + LINK_SIZE;
+           trypath = cc + 1 + LINK_SIZE;
            cc += GET(cc, 1);
            }
          else
-           hotpath = cc;
+           trypath = cc;
          }
        }
      else
        {
        SLJIT_ASSERT(has_alternatives);
-       stacksize = GET2(hotpath, 1);
+       stacksize = GET2(trypath, 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
        OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
-       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+       GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
        OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
        sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-       add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+       add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
-       hotpath += 1 + IMM2_SIZE;
+       trypath += 1 + IMM2_SIZE;
        }
      }
    else
      {
-     SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
+     SLJIT_ASSERT(has_alternatives && *trypath >= OP_ASSERT && *trypath <= OP_ASSERTBACK_NOT);
-     /* Similar code as PUSH_FALLBACK macro. */
+     /* Similar code as PUSH_BACKTRACK macro. */
-     assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));
+     assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
        return NULL;
-     memset(assert, 0, sizeof(assert_fallback));
+     memset(assert, 0, sizeof(assert_backtrack));
-     assert->common.cc = hotpath;
+     assert->common.cc = trypath;
-     FALLBACK_AS(bracket_fallback)->u.assert = assert;
+     BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
-     hotpath = compile_assert_hotpath(common, hotpath, assert, TRUE);
+     trypath = compile_assert_trypath(common, trypath, assert, TRUE);
      }
    }
- compile_hotpath(common, hotpath, cc, fallback);
+ compile_trypath(common, trypath, cc, backtrack);
  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
    return NULL;
  if (opcode == OP_ONCE)
    {
-   if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
      {
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
      /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 4570 
 if (opcode == OP_ONCE)
+Line 4966 
 if (opcode == OP_ONCE)
    else
      {
      stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;
-     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (FALLBACK_AS(bracket_fallback)->u.framesize + stacksize) * sizeof(sljit_w));
+     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize) * sizeof(sljit_w));
      if (ket == OP_KETRMAX)
        {
        /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 4605 
 if (has_alternatives)
+Line 5001 
 if (has_alternatives)
    if (opcode != OP_ONCE)
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
    if (ket != OP_KETRMAX)
-     FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
+     BACKTRACK_AS(bracket_backtrack)->alttrypath = LABEL();
    }
- /* Must be after the hotpath label. */
+ /* Must be after the trypath label. */
  if (offset != 0)
    {
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 4621 
 if (ket == OP_KETRMAX)
+Line 5017 
 if (ket == OP_KETRMAX)
    if (opcode == OP_ONCE || opcode >= OP_SBRA)
      {
      if (has_alternatives)
-       FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
+       BACKTRACK_AS(bracket_backtrack)->alttrypath = LABEL();
      /* Checking zero-length iteration. */
      if (opcode != OP_ONCE)
        CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0, rmaxlabel);
-Line 4631 
 if (ket == OP_KETRMAX)
+Line 5027 
 if (ket == OP_KETRMAX)
      }
    else
      JUMPTO(SLJIT_JUMP, rmaxlabel);
-   FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->recursivetrypath = LABEL();
    }
  if (bra == OP_BRAZERO)
-   FALLBACK_AS(bracket_fallback)->zerohotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->zerotrypath = LABEL();
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a fallback path! (From the viewpoint of OP_BRAMINZERO) */
+   /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
-   JUMPTO(SLJIT_JUMP, ((braminzero_fallback*)parent)->hotpath);
+   JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->trypath);
    if (braminzerojump != NULL)
      {
      JUMPHERE(braminzerojump);
      /* We need to release the end pointer to perform the
-     fallback for the zero-length iteration. When
+     backtrack for the zero-length iteration. When
      framesize is < 0, OP_ONCE will do the release itself. */
-     if (opcode == OP_ONCE && FALLBACK_AS(bracket_fallback)->u.framesize >= 0)
+     if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-Line 4655 
 if (bra == OP_BRAMINZERO)
+Line 5051 
 if (bra == OP_BRAMINZERO)
      else if (ket == OP_KETRMIN && opcode != OP_ONCE)
        free_stack(common, 1);
      }
-   /* Continue to the normal fallback. */
+   /* Continue to the normal backtrack. */
    }
  if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
-Line 4668 
 cc += 1 + LINK_SIZE;
+Line 5064 
 cc += 1 + LINK_SIZE;
  return cc;
  }
- static pcre_uchar *compile_bracketpos_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracketpos_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  int localptr;
  int cbraprivptr = 0;
-Line 4684 
 int stack;
+Line 5080 
 int stack;
  struct sljit_label *loop = NULL;
  struct jump_list *emptymatch = NULL;
- PUSH_FALLBACK(sizeof(bracketpos_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
  if (*cc == OP_BRAPOSZERO)
    {
    zero = TRUE;
-Line 4694 
 if (*cc == OP_BRAPOSZERO)
+Line 5090 
 if (*cc == OP_BRAPOSZERO)
  opcode = *cc;
  localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
- FALLBACK_AS(bracketpos_fallback)->localptr = localptr;
+ BACKTRACK_AS(bracketpos_backtrack)->localptr = localptr;
  switch(opcode)
    {
    case OP_BRAPOS:
-Line 4716 
 switch(opcode)
+Line 5112 
 switch(opcode)
    }
  framesize = get_framesize(common, cc, FALSE);
- FALLBACK_AS(bracketpos_fallback)->framesize = framesize;
+ BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
  if (framesize < 0)
    {
    stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;
    if (!zero)
      stacksize++;
-   FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
+   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
    allocate_stack(common, stacksize);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
-Line 4746 
 else
+Line 5142 
 else
      stacksize++;
    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
      stacksize++;
-   FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
+   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
    allocate_stack(common, stacksize);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 4773 
 if (opcode == OP_CBRAPOS || opcode == OP
+Line 5169 
 if (opcode == OP_CBRAPOS || opcode == OP
  loop = LABEL();
  while (*cc != OP_KETRPOS)
    {
-   fallback->top = NULL;
+   backtrack->top = NULL;
-   fallback->topfallbacks = NULL;
+   backtrack->topbacktracks = NULL;
    cc += GET(cc, 1);
-   compile_hotpath(common, ccbegin, cc, fallback);
+   compile_trypath(common, ccbegin, cc, backtrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      return NULL;
-Line 4838 
 while (*cc != OP_KETRPOS)
+Line 5234 
 while (*cc != OP_KETRPOS)
    JUMPTO(SLJIT_JUMP, loop);
    flush_stubs(common);
-   compile_fallbackpath(common, fallback->top);
+   compile_backtrackpath(common, backtrack->top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      return NULL;
-   set_jumps(fallback->topfallbacks, LABEL());
+   set_jumps(backtrack->topbacktracks, LABEL());
    if (framesize < 0)
      {
-Line 4871 
 while (*cc != OP_KETRPOS)
+Line 5267 
 while (*cc != OP_KETRPOS)
    ccbegin = cc + 1 + LINK_SIZE;
    }
- fallback->topfallbacks = NULL;
+ backtrack->topbacktracks = NULL;
  if (!zero)
    {
    if (framesize < 0)
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
    else /* TMP2 is set to [localptr] above. */
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));
    }
  /* None of them matched. */
-Line 4925 
 else
+Line 5321 
 else
    SLJIT_ASSERT(*opcode >= OP_CLASS || *opcode <= OP_XCLASS);
    *type = *opcode;
    cc++;
-   class_len = (*type < OP_XCLASS) ? (1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
+   class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
    *opcode = cc[class_len - 1];
    if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
      {
-Line 4978 
 if (end != NULL)
+Line 5374 
 if (end != NULL)
  return cc;
  }
- static pcre_uchar *compile_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_iterator_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  pcre_uchar type;
  int arg1 = -1, arg2 = -1;
-Line 4990 
 jump_list *nomatch = NULL;
+Line 5386 
 jump_list *nomatch = NULL;
  struct sljit_jump *jump = NULL;
  struct sljit_label *label;
- PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
-Line 5017 
 switch(opcode)
+Line 5413 
 switch(opcode)
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
      label = LABEL();
-     compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+     compile_char1_trypath(common, type, cc, &backtrack->topbacktracks);
      if (opcode == OP_UPTO || opcode == OP_CRRANGE)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
-Line 5041 
 switch(opcode)
+Line 5437 
 switch(opcode)
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
      label = LABEL();
-     compile_char1_hotpath(common, type, cc, &nomatch);
+     compile_char1_trypath(common, type, cc, &nomatch);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
      if (opcode <= OP_PLUS || (opcode == OP_CRRANGE && arg1 == 0))
        {
-Line 5057 
 switch(opcode)
+Line 5453 
 switch(opcode)
        }
      set_jumps(nomatch, LABEL());
      if (opcode == OP_PLUS || opcode == OP_CRRANGE)
-       add_jump(compiler, &fallback->topfallbacks,
+       add_jump(compiler, &backtrack->topbacktracks,
          CMP(SLJIT_C_LESS, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, opcode == OP_PLUS ? 2 : arg2 + 1));
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      }
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
    break;
    case OP_MINSTAR:
-Line 5069 
 switch(opcode)
+Line 5465 
 switch(opcode)
    allocate_stack(common, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    if (opcode == OP_MINPLUS)
-     add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
    break;
    case OP_MINUPTO:
-Line 5079 
 switch(opcode)
+Line 5475 
 switch(opcode)
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
    if (opcode == OP_CRMINRANGE)
-     add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
    break;
    case OP_QUERY:
-Line 5088 
 switch(opcode)
+Line 5484 
 switch(opcode)
    allocate_stack(common, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    if (opcode == OP_QUERY)
-     compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+     compile_char1_trypath(common, type, cc, &backtrack->topbacktracks);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
    break;
    case OP_EXACT:
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
    label = LABEL();
-   compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+   compile_char1_trypath(common, type, cc, &backtrack->topbacktracks);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
-Line 5109 
 switch(opcode)
+Line 5505 
 switch(opcode)
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
    label = LABEL();
-   compile_char1_hotpath(common, type, cc, &nomatch);
+   compile_char1_trypath(common, type, cc, &nomatch);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
    if (opcode != OP_POSUPTO)
      {
-Line 5126 
 switch(opcode)
+Line 5522 
 switch(opcode)
      }
    set_jumps(nomatch, LABEL());
    if (opcode == OP_POSPLUS)
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_LESS, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2));
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_LESS, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2));
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
    break;
    case OP_POSQUERY:
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
-   compile_char1_hotpath(common, type, cc, &nomatch);
+   compile_char1_trypath(common, type, cc, &nomatch);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
    set_jumps(nomatch, LABEL());
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-Line 5147 
 decrease_call_count(common);
+Line 5543 
 decrease_call_count(common);
  return end;
  }
- static SLJIT_INLINE pcre_uchar *compile_fail_accept_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_fail_accept_trypath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
- PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
  if (*cc == OP_FAIL)
    {
-   add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+   add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
    return cc + 1;
    }
-Line 5176 
 else
+Line 5572 
 else
    CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->acceptlabel);
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
- add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
  if (common->acceptlabel == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));
-Line 5187 
 if (common->acceptlabel == NULL)
+Line 5583 
 if (common->acceptlabel == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
  else
    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->acceptlabel);
- add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
  return cc + 1;
  }
- static SLJIT_INLINE pcre_uchar *compile_close_hotpath(compiler_common *common, pcre_uchar *cc)
+ static SLJIT_INLINE pcre_uchar *compile_close_trypath(compiler_common *common, pcre_uchar *cc)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1);
-Line 5207 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
+Line 5603 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
  return cc + 1 + IMM2_SIZE;
  }
- static void compile_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, fallback_common *parent)
+ static void compile_trypath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  while (cc < ccend)
    {
-Line 5246 
 while (cc < ccend)
+Line 5642 
 while (cc < ccend)
      case OP_NOT:
      case OP_NOTI:
      case OP_REVERSE:
-     cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+     cc = compile_char1_trypath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
      case OP_SET_SOM:
-     PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
      allocate_stack(common, 1);
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
      cc++;
      break;
      case OP_CHAR:
      case OP_CHARI:
-     cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+     if (common->mode == JIT_COMPILE)
+       cc = compile_charn_trypath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
+     else
+       cc = compile_char1_trypath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
      case OP_STAR:
-Line 5328 
 while (cc < ccend)
+Line 5727 
 while (cc < ccend)
      case OP_TYPEPOSPLUS:
      case OP_TYPEPOSQUERY:
      case OP_TYPEPOSUPTO:
-     cc = compile_iterator_hotpath(common, cc, parent);
+     cc = compile_iterator_trypath(common, cc, parent);
      break;
      case OP_CLASS:
      case OP_NCLASS:
      if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE)
-       cc = compile_iterator_hotpath(common, cc, parent);
+       cc = compile_iterator_trypath(common, cc, parent);
      else
-       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_char1_trypath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16
      case OP_XCLASS:
      if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)
-       cc = compile_iterator_hotpath(common, cc, parent);
+       cc = compile_iterator_trypath(common, cc, parent);
      else
-       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_char1_trypath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
  #endif
      case OP_REF:
      case OP_REFI:
      if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRMINRANGE)
-       cc = compile_ref_iterator_hotpath(common, cc, parent);
+       cc = compile_ref_iterator_trypath(common, cc, parent);
      else
-       cc = compile_ref_hotpath(common, cc, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks, TRUE, FALSE);
+       cc = compile_ref_trypath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
      break;
      case OP_RECURSE:
-     cc = compile_recurse_hotpath(common, cc, parent);
+     cc = compile_recurse_trypath(common, cc, parent);
      break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
-     PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
-     cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+     cc = compile_assert_trypath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
      break;
      case OP_BRAMINZERO:
-     PUSH_FALLBACK_NOVALUE(sizeof(braminzero_fallback), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
      cc = bracketend(cc + 1);
      if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
        {
-Line 5382 
 while (cc < ccend)
+Line 5781 
 while (cc < ccend)
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);
        }
-     FALLBACK_AS(braminzero_fallback)->hotpath = LABEL();
+     BACKTRACK_AS(braminzero_backtrack)->trypath = LABEL();
      if (cc[1] > OP_ASSERTBACK_NOT)
        decrease_call_count(common);
      break;
-Line 5395 
 while (cc < ccend)
+Line 5794 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SCBRA:
      case OP_SCOND:
-     cc = compile_bracket_hotpath(common, cc, parent);
+     cc = compile_bracket_trypath(common, cc, parent);
      break;
      case OP_BRAZERO:
      if (cc[1] > OP_ASSERTBACK_NOT)
-       cc = compile_bracket_hotpath(common, cc, parent);
+       cc = compile_bracket_trypath(common, cc, parent);
      else
        {
-       PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
+       PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
-       cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+       cc = compile_assert_trypath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
        }
      break;
-Line 5413 
 while (cc < ccend)
+Line 5812 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCBRAPOS:
      case OP_BRAPOSZERO:
-     cc = compile_bracketpos_hotpath(common, cc, parent);
+     cc = compile_bracketpos_trypath(common, cc, parent);
+     break;
+     case OP_MARK:
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+     SLJIT_ASSERT(common->mark_ptr != 0);
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+     allocate_stack(common, 1);
+     OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)(cc + 2));
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
+     cc += 1 + 2 + cc[1];
+     break;
+     case OP_COMMIT:
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+     cc += 1;
      break;
      case OP_FAIL:
      case OP_ACCEPT:
      case OP_ASSERT_ACCEPT:
-     cc = compile_fail_accept_hotpath(common, cc, parent);
+     cc = compile_fail_accept_trypath(common, cc, parent);
      break;
      case OP_CLOSE:
-     cc = compile_close_hotpath(common, cc);
+     cc = compile_close_trypath(common, cc);
      break;
      case OP_SKIPZERO:
-Line 5440 
 while (cc < ccend)
+Line 5857 
 while (cc < ccend)
  SLJIT_ASSERT(cc == ccend);
  }
- #undef PUSH_FALLBACK
+ #undef PUSH_BACKTRACK
- #undef PUSH_FALLBACK_NOVALUE
+ #undef PUSH_BACKTRACK_NOVALUE
- #undef FALLBACK_AS
+ #undef BACKTRACK_AS
- #define COMPILE_FALLBACKPATH(current) \
+ #define COMPILE_BACKTRACKPATH(current) \
    do \
      { \
-     compile_fallbackpath(common, (current)); \
+     compile_backtrackpath(common, (current)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return; \
      } \
    while (0)
- #define CURRENT_AS(type) ((type*)current)
+ #define CURRENT_AS(type) ((type *)current)
- static void compile_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_iterator_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
-Line 5475 
 switch(opcode)
+Line 5892 
 switch(opcode)
    case OP_CRRANGE:
    if (type == OP_ANYNL || type == OP_EXTUNI)
      {
-     set_jumps(current->topfallbacks, LABEL());
+     set_jumps(current->topbacktracks, LABEL());
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      free_stack(common, 1);
-     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
+     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->trypath);
      }
    else
      {
-Line 5491 
 switch(opcode)
+Line 5908 
 switch(opcode)
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      skip_char_back(common);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
+     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
      if (opcode == OP_PLUS || opcode == OP_CRRANGE)
-       set_jumps(current->topfallbacks, LABEL());
+       set_jumps(current->topbacktracks, LABEL());
      JUMPHERE(jump);
      free_stack(common, 2);
      }
-Line 5504 
 switch(opcode)
+Line 5921 
 switch(opcode)
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    if (opcode == OP_MINPLUS)
      {
-     set_jumps(current->topfallbacks, LABEL());
+     set_jumps(current->topbacktracks, LABEL());
-     current->topfallbacks = NULL;
+     current->topbacktracks = NULL;
      }
-   compile_char1_hotpath(common, type, cc, &current->topfallbacks);
+   compile_char1_trypath(common, type, cc, &current->topbacktracks);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
+   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    free_stack(common, 1);
    break;
-Line 5518 
 switch(opcode)
+Line 5935 
 switch(opcode)
    case OP_CRMINRANGE:
    if (opcode == OP_CRMINRANGE)
      {
-     set_jumps(current->topfallbacks, LABEL());
+     set_jumps(current->topbacktracks, LABEL());
-     current->topfallbacks = NULL;
+     current->topbacktracks = NULL;
      label = LABEL();
      }
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   compile_char1_hotpath(common, type, cc, &current->topfallbacks);
+   compile_char1_trypath(common, type, cc, &current->topbacktracks);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-Line 5534 
 switch(opcode)
+Line 5951 
 switch(opcode)
      CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2 + 1, label);
    if (opcode == OP_CRMINRANGE && arg1 == 0)
-     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
+     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
    else
-     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 2, CURRENT_AS(iterator_fallback)->hotpath);
+     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 2, CURRENT_AS(iterator_backtrack)->trypath);
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    free_stack(common, 2);
    break;
    case OP_QUERY:
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
+   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->trypath);
    jump = JUMP(SLJIT_JUMP);
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
+   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
    JUMPHERE(jump);
    free_stack(common, 1);
    break;
-Line 5559 
 switch(opcode)
+Line 5976 
 switch(opcode)
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
    jump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
-   compile_char1_hotpath(common, type, cc, &current->topfallbacks);
+   compile_char1_trypath(common, type, cc, &current->topbacktracks);
-   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
+   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    JUMPHERE(jump);
    free_stack(common, 1);
    break;
    case OP_EXACT:
    case OP_POSPLUS:
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    break;
    case OP_POSSTAR:
-Line 5582 
 switch(opcode)
+Line 5999 
 switch(opcode)
    }
  }
- static void compile_ref_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_ref_iterator_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
-Line 5591 
 pcre_uchar type;
+Line 6008 
 pcre_uchar type;
  type = cc[1 + IMM2_SIZE];
  if ((type & 0x1) == 0)
    {
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    free_stack(common, 1);
-   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
+   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->trypath);
    return;
    }
  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
+ CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->trypath);
- set_jumps(current->topfallbacks, LABEL());
+ set_jumps(current->topbacktracks, LABEL());
  free_stack(common, 2);
  }
- static void compile_recurse_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_recurse_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
- set_jumps(current->topfallbacks, LABEL());
+ set_jumps(current->topbacktracks, LABEL());
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
- free_stack(common, 1);
+ if (common->has_set_som && common->mark_ptr != 0)
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
+   {
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+   free_stack(common, 2);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);
+   }
+ else if (common->has_set_som || common->mark_ptr != 0)
+   {
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+   free_stack(common, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr, TMP2, 0);
+   }
  }
- static void compile_assert_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_assert_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
-Line 5630 
 if (*cc == OP_BRAZERO)
+Line 6059 
 if (*cc == OP_BRAZERO)
  if (bra == OP_BRAZERO)
    {
-   SLJIT_ASSERT(current->topfallbacks == NULL);
+   SLJIT_ASSERT(current->topbacktracks == NULL);
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    }
- if (CURRENT_AS(assert_fallback)->framesize < 0)
+ if (CURRENT_AS(assert_backtrack)->framesize < 0)
    {
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    if (bra == OP_BRAZERO)
      {
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);
+     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->trypath);
      free_stack(common, 1);
      }
    return;
-Line 5652 
 if (bra == OP_BRAZERO)
+Line 6081 
 if (bra == OP_BRAZERO)
    if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
      {
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);
+     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->trypath);
      free_stack(common, 1);
      return;
      }
-Line 5662 
 if (bra == OP_BRAZERO)
+Line 6091 
 if (bra == OP_BRAZERO)
  if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
    {
-   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr);
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_backtrack)->localptr);
    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-   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));
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_backtrack)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_backtrack)->framesize * sizeof(sljit_w));
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    }
  else
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
  if (bra == OP_BRAZERO)
    {
    /* We know there is enough place on the stack. */
    OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-   JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_fallback)->hotpath);
+   JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_backtrack)->trypath);
    JUMPHERE(brajump);
    }
  }
- static void compile_bracket_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_bracket_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  int opcode;
  int offset = 0;
- int localptr = CURRENT_AS(bracket_fallback)->localptr;
+ int localptr = CURRENT_AS(bracket_backtrack)->localptr;
  int stacksize;
  int count;
  pcre_uchar *cc = current->cc;
-Line 5696 
 jump_list *jumplist = NULL;
+Line 6125 
 jump_list *jumplist = NULL;
  jump_list *jumplistitem = NULL;
  pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
- assert_fallback *assert;
+ assert_backtrack *assert;
  BOOL has_alternatives;
  struct sljit_jump *brazero = NULL;
  struct sljit_jump *once = NULL;
-Line 5715 
 ket = *(bracketend(ccbegin) - 1 - LINK_S
+Line 6144 
 ket = *(bracketend(ccbegin) - 1 - LINK_S
  cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
-   has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_fallback)->u.condfailed != NULL;
+   has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;
  if (opcode == OP_CBRA || opcode == OP_SCBRA)
    offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;
  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
-Line 5742 
 else if (ket == OP_KETRMIN)
+Line 6171 
 else if (ket == OP_KETRMIN)
      if (opcode >= OP_SBRA || opcode == OP_ONCE)
        {
        /* Checking zero-length iteration. */
-       if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize < 0)
+       if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
-         CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, CURRENT_AS(bracket_fallback)->recursivehotpath);
+         CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, CURRENT_AS(bracket_backtrack)->recursivetrypath);
        else
          {
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         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);
+         CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_w), CURRENT_AS(bracket_backtrack)->recursivetrypath);
          }
        if (opcode != OP_ONCE)
          free_stack(common, 1);
        }
      else
-       JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->recursivehotpath);
+       JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursivetrypath);
      }
    rminlabel = LABEL();
    }
-Line 5766 
 else if (bra == OP_BRAZERO)
+Line 6195 
 else if (bra == OP_BRAZERO)
  if (SLJIT_UNLIKELY(opcode == OP_ONCE))
    {
-   if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
+   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
      {
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-Line 5821 
 else if (*cc == OP_ALT)
+Line 6250 
 else if (*cc == OP_ALT)
    cc = ccbegin + GET(ccbegin, 1);
    }
- COMPILE_FALLBACKPATH(current->top);
+ COMPILE_BACKTRACKPATH(current->top);
- if (current->topfallbacks)
+ if (current->topbacktracks)
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
    {
-Line 5831 
 if (SLJIT_UNLIKELY(opcode == OP_COND) ||
+Line 6260 
 if (SLJIT_UNLIKELY(opcode == OP_COND) ||
    if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)
      {
      SLJIT_ASSERT(has_alternatives);
-     assert = CURRENT_AS(bracket_fallback)->u.assert;
+     assert = CURRENT_AS(bracket_backtrack)->u.assert;
      if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);
-Line 5839 
 if (SLJIT_UNLIKELY(opcode == OP_COND) ||
+Line 6268 
 if (SLJIT_UNLIKELY(opcode == OP_COND) ||
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_w));
        }
      cond = JUMP(SLJIT_JUMP);
-     set_jumps(CURRENT_AS(bracket_fallback)->u.assert->condfailed, LABEL());
+     set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());
      }
-   else if (CURRENT_AS(bracket_fallback)->u.condfailed != NULL)
+   else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)
      {
      SLJIT_ASSERT(has_alternatives);
      cond = JUMP(SLJIT_JUMP);
-     set_jumps(CURRENT_AS(bracket_fallback)->u.condfailed, LABEL());
+     set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());
      }
    else
      SLJIT_ASSERT(!has_alternatives);
-Line 5857 
 if (has_alternatives)
+Line 6286 
 if (has_alternatives)
    do
      {
      current->top = NULL;
-     current->topfallbacks = NULL;
+     current->topbacktracks = NULL;
-     current->nextfallbacks = NULL;
+     current->nextbacktracks = NULL;
      if (*cc == OP_ALT)
        {
        ccprev = cc + 1 + LINK_SIZE;
-Line 5870 
 if (has_alternatives)
+Line 6299 
 if (has_alternatives)
          else
            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
          }
-       compile_hotpath(common, ccprev, cc, current);
+       compile_trypath(common, ccprev, cc, current);
        if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
          return;
        }
      /* Instructions after the current alternative is succesfully matched. */
-     /* There is a similar code in compile_bracket_hotpath. */
+     /* There is a similar code in compile_bracket_trypath. */
      if (opcode == OP_ONCE)
        {
-       if (CURRENT_AS(bracket_fallback)->u.framesize < 0)
+       if (CURRENT_AS(bracket_backtrack)->u.framesize < 0)
          {
          OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
          /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 5893 
 if (has_alternatives)
+Line 6322 
 if (has_alternatives)
          }
        else
          {
-         OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (CURRENT_AS(bracket_fallback)->u.framesize + 2) * sizeof(sljit_w));
+         OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (CURRENT_AS(bracket_backtrack)->u.framesize + 2) * sizeof(sljit_w));
          if (ket == OP_KETRMAX)
            {
            /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 5909 
 if (has_alternatives)
+Line 6338 
 if (has_alternatives)
        stacksize++;
      if (stacksize > 0) {
-       if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize >= 0)
+       if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
          allocate_stack(common, stacksize);
        else
          {
-Line 5939 
 if (has_alternatives)
+Line 6368 
 if (has_alternatives)
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);
        }
-     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->althotpath);
+     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alttrypath);
      if (opcode != OP_ONCE)
        {
-Line 5948 
 if (has_alternatives)
+Line 6377 
 if (has_alternatives)
        jumplist = jumplist->next;
        }
-     COMPILE_FALLBACKPATH(current->top);
+     COMPILE_BACKTRACKPATH(current->top);
-     if (current->topfallbacks)
+     if (current->topbacktracks)
-       set_jumps(current->topfallbacks, LABEL());
+       set_jumps(current->topbacktracks, LABEL());
-     SLJIT_ASSERT(!current->nextfallbacks);
+     SLJIT_ASSERT(!current->nextbacktracks);
      }
    while (*cc == OP_ALT);
    SLJIT_ASSERT(!jumplist);
-Line 5959 
 if (has_alternatives)
+Line 6388 
 if (has_alternatives)
    if (cond != NULL)
      {
      SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
-     assert = CURRENT_AS(bracket_fallback)->u.assert;
+     assert = CURRENT_AS(bracket_backtrack)->u.assert;
      if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
        {
-Line 5993 
 else if (opcode == OP_SBRA || opcode ==
+Line 6422 
 else if (opcode == OP_SBRA || opcode ==
  else if (opcode == OP_ONCE)
    {
    cc = ccbegin + GET(ccbegin, 1);
-   if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
+   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
      {
      /* Reset head and drop saved frame. */
      stacksize = (ket == OP_KETRMAX || ket == OP_KETRMIN || *cc == OP_ALT) ? 2 : 1;
-     free_stack(common, CURRENT_AS(bracket_fallback)->u.framesize + stacksize);
+     free_stack(common, CURRENT_AS(bracket_backtrack)->u.framesize + stacksize);
      }
    else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
      {
-Line 6007 
 else if (opcode == OP_ONCE)
+Line 6436 
 else if (opcode == OP_ONCE)
    JUMPHERE(once);
    /* Restore previous localptr */
-   if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
+   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_fallback)->u.framesize * sizeof(sljit_w));
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_backtrack)->u.framesize * sizeof(sljit_w));
    else if (ket == OP_KETRMIN)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
-Line 6021 
 else if (opcode == OP_ONCE)
+Line 6450 
 else if (opcode == OP_ONCE)
  if (ket == OP_KETRMAX)
    {
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_fallback)->recursivehotpath);
+   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursivetrypath);
    if (bra == OP_BRAZERO)
      {
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
-     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);
+     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zerotrypath);
      JUMPHERE(brazero);
      }
    free_stack(common, 1);
-Line 6034 
 else if (ket == OP_KETRMIN)
+Line 6463 
 else if (ket == OP_KETRMIN)
    {
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   /* OP_ONCE removes everything in case of a fallback, so we don't
+   /* OP_ONCE removes everything in case of a backtrack, so we don't
    need to explicitly release the STR_PTR. The extra release would
    affect badly the free_stack(2) above. */
    if (opcode != OP_ONCE)
-Line 6048 
 else if (ket == OP_KETRMIN)
+Line 6477 
 else if (ket == OP_KETRMIN)
  else if (bra == OP_BRAZERO)
    {
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);
+   JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zerotrypath);
    JUMPHERE(brazero);
    }
  }
- static void compile_bracketpos_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_bracketpos_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  int offset;
  struct sljit_jump *jump;
- if (CURRENT_AS(bracketpos_fallback)->framesize < 0)
+ if (CURRENT_AS(bracketpos_backtrack)->framesize < 0)
    {
    if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
      {
-Line 6069 
 if (CURRENT_AS(bracketpos_fallback)->fra
+Line 6498 
 if (CURRENT_AS(bracketpos_fallback)->fra
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
      }
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
-   free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
+   free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
    return;
    }
- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr);
+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_backtrack)->localptr);
  add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
- if (current->topfallbacks)
+ if (current->topbacktracks)
    {
    jump = JUMP(SLJIT_JUMP);
-   set_jumps(current->topfallbacks, LABEL());
+   set_jumps(current->topbacktracks, LABEL());
    /* Drop the stack frame. */
-   free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
+   free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
    JUMPHERE(jump);
    }
- 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));
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_backtrack)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_backtrack)->framesize * sizeof(sljit_w));
  }
- static void compile_braminzero_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_braminzero_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
- assert_fallback fallback;
+ assert_backtrack backtrack;
  current->top = NULL;
- current->topfallbacks = NULL;
+ current->topbacktracks = NULL;
- current->nextfallbacks = NULL;
+ current->nextbacktracks = NULL;
  if (current->cc[1] > OP_ASSERTBACK_NOT)
    {
-   /* Manual call of compile_bracket_hotpath and compile_bracket_fallbackpath. */
+   /* Manual call of compile_bracket_trypath and compile_bracket_backtrackpath. */
-   compile_bracket_hotpath(common, current->cc, current);
+   compile_bracket_trypath(common, current->cc, current);
-   compile_bracket_fallbackpath(common, current->top);
+   compile_bracket_backtrackpath(common, current->top);
    }
  else
    {
-   memset(&fallback, 0, sizeof(fallback));
+   memset(&backtrack, 0, sizeof(backtrack));
-   fallback.common.cc = current->cc;
+   backtrack.common.cc = current->cc;
-   fallback.hotpath = CURRENT_AS(braminzero_fallback)->hotpath;
+   backtrack.trypath = CURRENT_AS(braminzero_backtrack)->trypath;
-   /* Manual call of compile_assert_hotpath. */
+   /* Manual call of compile_assert_trypath. */
-   compile_assert_hotpath(common, current->cc, &fallback, FALSE);
+   compile_assert_trypath(common, current->cc, &backtrack, FALSE);
    }
- SLJIT_ASSERT(!current->nextfallbacks && !current->topfallbacks);
+ SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);
  }
- static void compile_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_backtrackpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  while (current)
    {
-   if (current->nextfallbacks != NULL)
+   if (current->nextbacktracks != NULL)
-     set_jumps(current->nextfallbacks, LABEL());
+     set_jumps(current->nextbacktracks, LABEL());
    switch(*current->cc)
      {
      case OP_SET_SOM:
-Line 6198 
 while (current)
+Line 6627 
 while (current)
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
      case OP_XCLASS:
  #endif
-     compile_iterator_fallbackpath(common, current);
+     compile_iterator_backtrackpath(common, current);
      break;
      case OP_REF:
      case OP_REFI: