Variable renamings in the PCRE-JIT compiler

git-svn-id: svn://vcs.exim.org/pcre/code/trunk@970 2f5784b3-3f2a-0410-8824-cb99058d5e15

2 files changed, 501 insertions, 499 deletions

diff --git a/ChangeLog b/ChangeLog
index f5ce796..5a36a1f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -118,6 +118,8 @@ Version 8.31
 
 32. Put spaces around SLJIT_PRINT_D in the JIT compiler. Required by CXX11.
 
+33. Variable renamings in the PCRE-JIT compiler. No functionality change.
+
 
 Version 8.30 04-February-2012
 -----------------------------
diff --git a/pcre_jit_compile.c b/pcre_jit_compile.c
index 3af8c4b..7191ac3 100644
--- a/pcre_jit_compile.c
+++ b/pcre_jit_compile.c
@@ -82,23 +82,23 @@ The code generator follows the recursive nature of the PERL compatible regular
 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 'fallback' path. Branch instructions are expesive for all CPUs, so we avoid taken
-branches on the hot path.
+The 'true' case is called as the try path (expected path), and the other is called as
+the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
+branches on the try path.
 
  Greedy star operator (*) :
-   Hot path: match happens.
-   Fallback path: match failed.
+   Try path: match happens.
+   Backtrack path: match failed.
  Non-greedy star operator (*?) :
-   Hot path: no need to perform a match.
-   Fallback path: match is required.
+   Try path: no need to perform a match.
+   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
@@ -108,34 +108,34 @@ we have the following regular expression:
 
 The generated code will be the following:
 
- A hot path
- '(' hot path (pushing arguments to the stack)
- B hot path
- ')' hot path (pushing arguments to the stack)
- D hot path
+ A try path
+ '(' try path (pushing arguments to the stack)
+ B try path
+ ')' try path (pushing arguments to the stack)
+ D try path
  return with successful match
 
- D fallback path
- ')' fallback path (If we arrived from "C" jump to the fallback of "C")
- B fallback path
+ D backtrack path
+ ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
+ B backtrack path
  C expected path
- jump to D hot path
- C fallback path
- A fallback path
+ jump to D try path
+ C backtrack 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
- frame and continue the execution on the fallback code paths.
+ the try path eventually. Otherwise it needs to clear out its own stack
+ 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.
 
@@ -188,71 +188,71 @@ 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
-the aguments for compile_fallbackpath. Must be the first member
+code generator. It is allocated by compile_trypath, and contains
+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;
-  jump_list *nextfallbacks;
+  struct backtrack_common *prev;
+  jump_list *nextbacktracks;
   /* Internal stack (for component operators). */
-  struct fallback_common *top;
-  jump_list *topfallbacks;
+  struct backtrack_common *top;
+  jump_list *topbacktracks;
   /* Opcode pointer. */
   pcre_uchar *cc;
-} fallback_common;
+} backtrack_common;
 
-typedef struct assert_fallback {
-  fallback_common common;
+typedef struct assert_backtrack {
+  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;
-} assert_fallback;
+  struct sljit_label *trypath;
+} assert_backtrack;
 
-typedef struct bracket_fallback {
-  fallback_common common;
+typedef struct bracket_backtrack {
+  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 {
-  fallback_common common;
+typedef struct bracketpos_backtrack {
+  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 {
-  fallback_common common;
-  struct sljit_label *hotpath;
-} braminzero_fallback;
+typedef struct braminzero_backtrack {
+  backtrack_common common;
+  struct sljit_label *trypath;
+} braminzero_backtrack;
 
-typedef struct iterator_fallback {
-  fallback_common common;
+typedef struct iterator_backtrack {
+  backtrack_common common;
   /* Next iteration. */
-  struct sljit_label *hotpath;
-} iterator_fallback;
+  struct sljit_label *trypath;
+} iterator_backtrack;
 
 typedef struct recurse_entry {
   struct recurse_entry *next;
@@ -264,9 +264,9 @@ typedef struct recurse_entry {
   int start;
 } recurse_entry;
 
-typedef struct recurse_fallback {
-  fallback_common common;
-} recurse_fallback;
+typedef struct recurse_backtrack {
+  backtrack_common common;
+} recurse_backtrack;
 
 typedef struct compiler_common {
   struct sljit_compiler *compiler;
@@ -467,8 +467,8 @@ return cc;
  init_frame
  get_localsize
  copy_locals
- compile_hotpath
- compile_fallbackpath
+ compile_trypath
+ compile_backtrackpath
 */
 
 static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
@@ -1622,24 +1622,24 @@ JUMPHERE(jump);
 return return_value;
 }
 
-static void fallback_at_str_end(compiler_common *common, jump_list **fallbacks)
+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, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+  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, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 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, fallbacks, JUMP(SLJIT_JUMP));
+  add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   }
 else
   {
@@ -1789,7 +1789,7 @@ 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;
@@ -1797,7 +1797,7 @@ 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)
   {
@@ -1805,12 +1805,12 @@ 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));
   }
 }
 
@@ -2733,7 +2733,7 @@ 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;
@@ -2834,20 +2834,20 @@ 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
 
@@ -2873,10 +2873,10 @@ 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
 
@@ -2912,11 +2912,11 @@ 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;
@@ -2931,7 +2931,7 @@ int invertcmp, numberofcmps;
 unsigned int charoffset;
 
 /* Although SUPPORT_UTF must be defined, we are not necessary in utf mode. */
-fallback_at_str_end(common, fallbacks);
+detect_partial_match(common, backtracks);
 read_char(common);
 
 if ((*cc++ & XCL_MAP) != 0)
@@ -3082,7 +3082,7 @@ typeoffset = 0;
 while (*cc != XCL_END)
   {
   compares--;
-  invertcmp = (compares == 0 && list != fallbacks);
+  invertcmp = (compares == 0 && list != backtracks);
   jump = NULL;
 
   if (*cc == XCL_SINGLE)
@@ -3164,7 +3164,7 @@ 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;
@@ -3237,7 +3237,7 @@ 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)
@@ -3249,7 +3249,7 @@ 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;
@@ -3268,47 +3268,47 @@ 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:
-  fallback_at_str_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:
-  fallback_at_str_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:
-  fallback_at_str_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:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   read_char(common);
   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
     {
@@ -3319,17 +3319,17 @@ switch(type)
       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));
     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:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
 #ifdef SUPPORT_UTF
   if (common->utf)
     {
@@ -3357,7 +3357,7 @@ switch(type)
   return cc;
 
   case OP_ANYBYTE:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   return cc;
 
@@ -3370,13 +3370,13 @@ 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:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   read_char(common);
   jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
   /* We don't need to handle soft partial matching case. */
@@ -3389,7 +3389,7 @@ switch(type)
   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]);
@@ -3397,27 +3397,27 @@ switch(type)
 
   case OP_NOT_HSPACE:
   case OP_HSPACE:
-  fallback_at_str_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:
-  fallback_at_str_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:
-  fallback_at_str_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);
@@ -3447,7 +3447,7 @@ switch(type)
     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));
     if (common->mode == JIT_COMPILE)
-      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));
     else
       {
       jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
@@ -3455,21 +3455,21 @@ switch(type)
       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, fallbacks, JUMP(SLJIT_C_NOT_EQUAL));
+      add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));
       check_partial(common, TRUE);
-      add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+      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, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 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, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
     }
   else
     {
@@ -3478,26 +3478,26 @@ 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, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+      add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
+      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]);
@@ -3508,16 +3508,16 @@ switch(type)
   return cc;
 
   case OP_EOD:
-  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_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:
@@ -3525,25 +3525,25 @@ 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_GREATER_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, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 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;
@@ -3551,13 +3551,13 @@ 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;
@@ -3566,7 +3566,7 @@ switch(type)
   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]);
@@ -3576,25 +3576,25 @@ switch(type)
     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));
     if (common->mode == JIT_COMPILE)
-      add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
+      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, 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));
       check_partial(common, TRUE);
-      add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+      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, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 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;
@@ -3608,16 +3608,16 @@ switch(type)
   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);
     }
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   read_char(common);
 #ifdef SUPPORT_UTF
   if (common->utf)
@@ -3629,7 +3629,7 @@ switch(type)
     c = *cc;
   if (type == OP_CHAR || !char_has_othercase(common, cc))
     {
-    add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
     return cc + length;
     }
   oc = char_othercase(common, c);
@@ -3637,19 +3637,19 @@ switch(type)
   if (ispowerof2(bit))
     {
     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
-    add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | 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:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   length = 1;
 #ifdef SUPPORT_UTF
   if (common->utf)
@@ -3660,12 +3660,12 @@ 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));
@@ -3690,7 +3690,7 @@ 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);
@@ -3698,19 +3698,19 @@ 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, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
+      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
       }
     }
   return cc + length;
 
   case OP_CLASS:
   case OP_NCLASS:
-  fallback_at_str_end(common, fallbacks);
+  detect_partial_match(common, backtracks);
   read_char(common);
 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   jump[0] = NULL;
@@ -3723,7 +3723,7 @@ 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;
       }
     }
@@ -3733,7 +3733,7 @@ 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]);
@@ -3742,7 +3742,7 @@ 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
 
@@ -3757,7 +3757,7 @@ 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);
@@ -3767,7 +3767,7 @@ switch(type)
     {
     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));
-    add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
     }
   check_start_used_ptr(common);
   return cc + LINK_SIZE;
@@ -3776,7 +3776,7 @@ 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. */
@@ -3828,21 +3828,21 @@ 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;
@@ -3850,7 +3850,7 @@ 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));
@@ -3859,44 +3859,44 @@ if (!common->jscript_compat)
     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_fallbackpath(compiler_common *, struct fallback_common *);
+static void compile_trypath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_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); \
-    fallback->prev = parent->top; \
-    fallback->cc = (ccstart); \
-    parent->top = fallback; \
+    memset(backtrack, 0, size); \
+    backtrack->prev = parent->top; \
+    backtrack->cc = (ccstart); \
+    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); \
-    fallback->prev = parent->top; \
-    fallback->cc = (ccstart); \
-    parent->top = fallback; \
+    memset(backtrack, 0, size); \
+    backtrack->prev = parent->top; \
+    backtrack->cc = (ccstart); \
+    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;
@@ -3907,7 +3907,7 @@ 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)
@@ -3924,13 +3924,13 @@ if (common->utf && *cc == OP_REFI)
   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);
   if (common->mode == JIT_COMPILE)
-    add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
+    add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
   else
     {
-    add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+    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, fallbacks, JUMP(SLJIT_JUMP));
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
     JUMPHERE(nopartial);
     }
   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
@@ -3945,10 +3945,10 @@ else
   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, fallbacks, partial);
+    add_jump(compiler, backtracks, partial);
 
   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)
     {
@@ -3960,10 +3960,10 @@ else
     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, 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));
     JUMPHERE(partial);
     check_partial(common, FALSE);
-    add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
     JUMPHERE(nopartial);
     }
   }
@@ -3971,17 +3971,17 @@ else
 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;
@@ -3990,7 +3990,7 @@ 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;
@@ -4042,14 +4042,14 @@ 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)
     {
@@ -4077,7 +4077,7 @@ if (!minimize)
     }
 
   JUMPHERE(zerolength);
-  FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+  BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
 
   decrease_call_count(common);
   return cc;
@@ -4095,13 +4095,13 @@ 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)
@@ -4109,7 +4109,7 @@ 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);
@@ -4122,15 +4122,15 @@ 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)
@@ -4175,21 +4175,21 @@ if (entry->entry == NULL)
 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;
@@ -4208,8 +4208,8 @@ if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
 localptr = PRIV_DATA(cc);
 SLJIT_ASSERT(localptr != 0);
 framesize = get_framesize(common, cc, FALSE);
-fallback->framesize = framesize;
-fallback->localptr = localptr;
+backtrack->framesize = framesize;
+backtrack->localptr = localptr;
 opcode = *cc;
 SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
 found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
@@ -4218,7 +4218,7 @@ 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);
@@ -4241,21 +4241,21 @@ 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;
-  altfallback.topfallbacks = NULL;
+  altbacktrack.top = NULL;
+  altbacktrack.topbacktracks = NULL;
 
   if (*ccbegin == OP_ALT)
     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
 
-  altfallback.cc = ccbegin;
-  compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);
+  altbacktrack.cc = ccbegin;
+  compile_trypath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
     {
     common->leavelabel = save_leavelabel;
@@ -4310,7 +4310,7 @@ 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;
@@ -4319,7 +4319,7 @@ while (1)
     common->accept = save_accept;
     return NULL;
     }
-  set_jumps(altfallback.topfallbacks, LABEL());
+  set_jumps(altbacktrack.topbacktracks, LABEL());
 
   if (*cc != OP_ALT)
     break;
@@ -4396,12 +4396,12 @@ if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
 
   if (bra == OP_BRAZERO)
     {
-    fallback->hotpath = LABEL();
-    sljit_set_label(jump, fallback->hotpath);
+    backtrack->trypath = LABEL();
+    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)
       {
@@ -4409,7 +4409,7 @@ if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
       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
@@ -4439,18 +4439,18 @@ 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);
-    set_jumps(fallback->common.topfallbacks, LABEL());
-    fallback->common.topfallbacks = NULL;
+    SLJIT_ASSERT(found == &backtrack->common.topbacktracks);
+    set_jumps(backtrack->common.topbacktracks, LABEL());
+    backtrack->common.topbacktracks = NULL;
     }
   }
 
@@ -4625,26 +4625,26 @@ 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)
   {
@@ -4655,12 +4655,12 @@ if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
 
 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. */
-  parent->top = fallback->prev;
+  /* Drop this bracket_backtrack. */
+  parent->top = backtrack->prev;
   return bracketend(cc);
   }
 
@@ -4672,10 +4672,10 @@ 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;
-  if (*hotpath == OP_NRREF)
+  has_alternatives = (*trypath == OP_RREF) ? FALSE : TRUE;
+  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)
@@ -4696,17 +4696,17 @@ if (opcode == OP_CBRA || opcode == OP_SCBRA)
   offset = GET2(ccbegin, 1 + LINK_SIZE);
   localptr = OVECTOR_PRIV(offset);
   offset <<= 1;
-  FALLBACK_AS(bracket_fallback)->localptr = localptr;
-  hotpath += IMM2_SIZE;
+  BACKTRACK_AS(bracket_backtrack)->localptr = localptr;
+  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. */
@@ -4731,7 +4731,7 @@ 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)
     {
@@ -4748,7 +4748,7 @@ 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);
@@ -4757,7 +4757,7 @@ 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);
       }
@@ -4771,19 +4771,19 @@ 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)
@@ -4807,22 +4807,22 @@ 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);
       }
     }
   }
@@ -4856,17 +4856,17 @@ 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),
-      CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-    hotpath += 1 + IMM2_SIZE;
+    add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
+      CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(trypath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+    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);
@@ -4877,17 +4877,17 @@ if (opcode == OP_COND || opcode == OP_SCOND)
     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)
@@ -4897,27 +4897,27 @@ if (opcode == OP_COND || opcode == OP_SCOND)
     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);
@@ -4927,31 +4927,31 @@ if (opcode == OP_COND || opcode == OP_SCOND)
       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));
-      hotpath += 1 + IMM2_SIZE;
+      add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+      trypath += 1 + IMM2_SIZE;
       }
     }
   else
     {
-    SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
-    /* Similar code as PUSH_FALLBACK macro. */
-    assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));
+    SLJIT_ASSERT(has_alternatives && *trypath >= OP_ASSERT && *trypath <= OP_ASSERTBACK_NOT);
+    /* Similar code as PUSH_BACKTRACK macro. */
+    assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));
     if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
       return NULL;
-    memset(assert, 0, sizeof(assert_fallback));
-    assert->common.cc = hotpath;
-    FALLBACK_AS(bracket_fallback)->u.assert = assert;
-    hotpath = compile_assert_hotpath(common, hotpath, assert, TRUE);
+    memset(assert, 0, sizeof(assert_backtrack));
+    assert->common.cc = trypath;
+    BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
+    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. */
@@ -4966,7 +4966,7 @@ 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. */
@@ -5001,10 +5001,10 @@ 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);
@@ -5017,7 +5017,7 @@ 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);
@@ -5027,23 +5027,23 @@ 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) */
-  JUMPTO(SLJIT_JUMP, ((braminzero_fallback *)parent)->hotpath);
+  /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
+  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));
@@ -5051,7 +5051,7 @@ 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)
@@ -5064,10 +5064,10 @@ 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;
@@ -5080,7 +5080,7 @@ 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;
@@ -5090,7 +5090,7 @@ 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:
@@ -5112,13 +5112,13 @@ 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);
 
@@ -5142,7 +5142,7 @@ 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);
@@ -5169,11 +5169,11 @@ if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
 loop = LABEL();
 while (*cc != OP_KETRPOS)
   {
-  fallback->top = NULL;
-  fallback->topfallbacks = NULL;
+  backtrack->top = 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;
 
@@ -5234,10 +5234,10 @@ 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)
     {
@@ -5267,13 +5267,13 @@ 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. */
@@ -5374,10 +5374,10 @@ 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;
@@ -5386,7 +5386,7 @@ 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);
 
@@ -5413,7 +5413,7 @@ 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);
@@ -5437,7 +5437,7 @@ 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))
       {
@@ -5453,11 +5453,11 @@ 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:
@@ -5465,8 +5465,8 @@ 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));
-  FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+    add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
+  BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
   break;
 
   case OP_MINUPTO:
@@ -5475,8 +5475,8 @@ 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));
-  FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+    add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
+  BACKTRACK_AS(iterator_backtrack)->trypath = LABEL();
   break;
 
   case OP_QUERY:
@@ -5484,14 +5484,14 @@ 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);
-  FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+    compile_char1_trypath(common, type, cc, &backtrack->topbacktracks);
+  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);
@@ -5505,7 +5505,7 @@ 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)
     {
@@ -5522,13 +5522,13 @@ 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);
@@ -5543,16 +5543,16 @@ 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;
   }
 
@@ -5572,7 +5572,7 @@ 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));
@@ -5583,11 +5583,11 @@ 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);
@@ -5603,10 +5603,10 @@ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
 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)
   {
@@ -5642,11 +5642,11 @@ 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, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
@@ -5657,9 +5657,9 @@ while (cc < ccend)
     case OP_CHAR:
     case OP_CHARI:
     if (common->mode == JIT_COMPILE)
-      cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+      cc = compile_charn_trypath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
     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;
 
     case OP_STAR:
@@ -5727,48 +5727,48 @@ 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);
-    cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+    PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
+    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)
       {
@@ -5781,7 +5781,7 @@ 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;
@@ -5794,16 +5794,16 @@ 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);
-      cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+      PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
+      cc = compile_assert_trypath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
       }
     break;
 
@@ -5812,11 +5812,11 @@ 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_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+    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);
@@ -5829,18 +5829,18 @@ while (cc < ccend)
     break;
 
     case OP_COMMIT:
-    PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+    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:
@@ -5857,14 +5857,14 @@ while (cc < ccend)
 SLJIT_ASSERT(cc == ccend);
 }
 
-#undef PUSH_FALLBACK
-#undef PUSH_FALLBACK_NOVALUE
-#undef FALLBACK_AS
+#undef PUSH_BACKTRACK
+#undef PUSH_BACKTRACK_NOVALUE
+#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; \
     } \
@@ -5872,7 +5872,7 @@ SLJIT_ASSERT(cc == ccend);
 
 #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;
@@ -5892,10 +5892,10 @@ 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
     {
@@ -5908,9 +5908,9 @@ 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);
     }
@@ -5921,13 +5921,13 @@ switch(opcode)
   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   if (opcode == OP_MINPLUS)
     {
-    set_jumps(current->topfallbacks, LABEL());
-    current->topfallbacks = NULL;
+    set_jumps(current->topbacktracks, LABEL());
+    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);
-  set_jumps(current->topfallbacks, LABEL());
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
+  set_jumps(current->topbacktracks, LABEL());
   free_stack(common, 1);
   break;
 
@@ -5935,12 +5935,12 @@ switch(opcode)
   case OP_CRMINRANGE:
   if (opcode == OP_CRMINRANGE)
     {
-    set_jumps(current->topfallbacks, LABEL());
-    current->topfallbacks = NULL;
+    set_jumps(current->topbacktracks, LABEL());
+    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);
@@ -5951,23 +5951,23 @@ 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;
@@ -5976,16 +5976,16 @@ 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);
-  JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
-  set_jumps(current->topfallbacks, LABEL());
+  compile_char1_trypath(common, type, cc, &current->topbacktracks);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->trypath);
+  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:
@@ -5999,7 +5999,7 @@ 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;
@@ -6008,24 +6008,24 @@ 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);
-set_jumps(current->topfallbacks, LABEL());
+CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->trypath);
+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());
 
 if (common->has_set_som && common->mark_ptr != 0)
   {
@@ -6043,7 +6043,7 @@ else if (common->has_set_som || common->mark_ptr != 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;
@@ -6059,18 +6059,18 @@ 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;
@@ -6081,7 +6081,7 @@ 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;
     }
@@ -6091,31 +6091,31 @@ 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;
@@ -6125,7 +6125,7 @@ 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;
@@ -6144,7 +6144,7 @@ ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);
 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))
@@ -6171,18 +6171,18 @@ 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)
-        CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, CURRENT_AS(bracket_fallback)->recursivehotpath);
+      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_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();
   }
@@ -6195,7 +6195,7 @@ 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));
@@ -6250,9 +6250,9 @@ else if (*cc == OP_ALT)
   cc = ccbegin + GET(ccbegin, 1);
   }
 
-COMPILE_FALLBACKPATH(current->top);
-if (current->topfallbacks)
-  set_jumps(current->topfallbacks, LABEL());
+COMPILE_BACKTRACKPATH(current->top);
+if (current->topbacktracks)
+  set_jumps(current->topbacktracks, LABEL());
 
 if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
   {
@@ -6260,7 +6260,7 @@ if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
   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);
@@ -6268,13 +6268,13 @@ if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
       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);
@@ -6286,8 +6286,8 @@ if (has_alternatives)
   do
     {
     current->top = NULL;
-    current->topfallbacks = NULL;
-    current->nextfallbacks = NULL;
+    current->topbacktracks = NULL;
+    current->nextbacktracks = NULL;
     if (*cc == OP_ALT)
       {
       ccprev = cc + 1 + LINK_SIZE;
@@ -6299,16 +6299,16 @@ 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. */
@@ -6322,7 +6322,7 @@ 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. */
@@ -6338,7 +6338,7 @@ 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
         {
@@ -6368,7 +6368,7 @@ 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)
       {
@@ -6377,10 +6377,10 @@ if (has_alternatives)
       jumplist = jumplist->next;
       }
 
-    COMPILE_FALLBACKPATH(current->top);
-    if (current->topfallbacks)
-      set_jumps(current->topfallbacks, LABEL());
-    SLJIT_ASSERT(!current->nextfallbacks);
+    COMPILE_BACKTRACKPATH(current->top);
+    if (current->topbacktracks)
+      set_jumps(current->topbacktracks, LABEL());
+    SLJIT_ASSERT(!current->nextbacktracks);
     }
   while (*cc == OP_ALT);
   SLJIT_ASSERT(!jumplist);
@@ -6388,7 +6388,7 @@ 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)
 
       {
@@ -6422,11 +6422,11 @@ else if (opcode == OP_SBRA || opcode == OP_SCOND)
 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))
     {
@@ -6436,8 +6436,8 @@ else if (opcode == OP_ONCE)
 
   JUMPHERE(once);
   /* Restore previous localptr */
-  if (CURRENT_AS(bracket_fallback)->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));
+  if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
+    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));
@@ -6450,11 +6450,11 @@ 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);
@@ -6463,7 +6463,7 @@ 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)
@@ -6477,18 +6477,18 @@ 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)
     {
@@ -6498,57 +6498,57 @@ if (CURRENT_AS(bracketpos_fallback)->framesize < 0)
     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());
-  free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
+  set_jumps(current->topbacktracks, LABEL());
+  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->nextfallbacks = NULL;
+current->topbacktracks = NULL;
+current->nextbacktracks = NULL;
 if (current->cc[1] > OP_ASSERTBACK_NOT)
   {
-  /* Manual call of compile_bracket_hotpath and compile_bracket_fallbackpath. */
-  compile_bracket_hotpath(common, current->cc, current);
-  compile_bracket_fallbackpath(common, current->top);
+  /* Manual call of compile_bracket_trypath and compile_bracket_backtrackpath. */
+  compile_bracket_trypath(common, current->cc, current);
+  compile_bracket_backtrackpath(common, current->top);
   }
 else
   {
-  memset(&fallback, 0, sizeof(fallback));
-  fallback.common.cc = current->cc;
-  fallback.hotpath = CURRENT_AS(braminzero_fallback)->hotpath;
-  /* Manual call of compile_assert_hotpath. */
-  compile_assert_hotpath(common, current->cc, &fallback, FALSE);
+  memset(&backtrack, 0, sizeof(backtrack));
+  backtrack.common.cc = current->cc;
+  backtrack.trypath = CURRENT_AS(braminzero_backtrack)->trypath;
+  /* Manual call of compile_assert_trypath. */
+  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)
-    set_jumps(current->nextfallbacks, LABEL());
+  if (current->nextbacktracks != NULL)
+    set_jumps(current->nextbacktracks, LABEL());
   switch(*current->cc)
     {
     case OP_SET_SOM:
@@ -6627,23 +6627,23 @@ 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:
-    compile_ref_iterator_fallbackpath(common, current);
+    compile_ref_iterator_backtrackpath(common, current);
     break;
 
     case OP_RECURSE:
-    compile_recurse_fallbackpath(common, current);
+    compile_recurse_backtrackpath(common, current);
     break;
 
     case OP_ASSERT:
     case OP_ASSERT_NOT:
     case OP_ASSERTBACK:
     case OP_ASSERTBACK_NOT:
-    compile_assert_fallbackpath(common, current);
+    compile_assert_backtrackpath(common, current);
     break;
 
     case OP_ONCE:
@@ -6654,14 +6654,14 @@ while (current)
     case OP_SBRA:
     case OP_SCBRA:
     case OP_SCOND:
-    compile_bracket_fallbackpath(common, current);
+    compile_bracket_backtrackpath(common, current);
     break;
 
     case OP_BRAZERO:
     if (current->cc[1] > OP_ASSERTBACK_NOT)
-      compile_bracket_fallbackpath(common, current);
+      compile_bracket_backtrackpath(common, current);
     else
-      compile_assert_fallbackpath(common, current);
+      compile_assert_backtrackpath(common, current);
     break;
 
     case OP_BRAPOS:
@@ -6669,11 +6669,11 @@ while (current)
     case OP_SBRAPOS:
     case OP_SCBRAPOS:
     case OP_BRAPOSZERO:
-    compile_bracketpos_fallbackpath(common, current);
+    compile_bracketpos_backtrackpath(common, current);
     break;
 
     case OP_BRAMINZERO:
-    compile_braminzero_fallbackpath(common, current);
+    compile_braminzero_backtrackpath(common, current);
     break;
 
     case OP_MARK:
@@ -6693,7 +6693,7 @@ while (current)
     case OP_FAIL:
     case OP_ACCEPT:
     case OP_ASSERT_ACCEPT:
-    set_jumps(current->topfallbacks, LABEL());
+    set_jumps(current->topbacktracks, LABEL());
     break;
 
     default:
@@ -6714,7 +6714,7 @@ int localsize = get_localsize(common, ccbegin, ccend);
 int framesize = get_framesize(common, cc, TRUE);
 int alternativesize;
 BOOL needsframe;
-fallback_common altfallback;
+backtrack_common altbacktrack;
 struct sljit_label *save_leavelabel = common->leavelabel;
 jump_list *save_leave = common->leave;
 struct sljit_jump *jump;
@@ -6740,22 +6740,22 @@ if (needsframe)
 if (alternativesize > 0)
   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
 
-memset(&altfallback, 0, sizeof(fallback_common));
+memset(&altbacktrack, 0, sizeof(backtrack_common));
 common->leavelabel = NULL;
 common->acceptlabel = NULL;
 common->leave = NULL;
 common->accept = NULL;
-altfallback.cc = ccbegin;
+altbacktrack.cc = ccbegin;
 cc += GET(cc, 1);
 while (1)
   {
-  altfallback.top = NULL;
-  altfallback.topfallbacks = NULL;
+  altbacktrack.top = NULL;
+  altbacktrack.topbacktracks = NULL;
 
-  if (altfallback.cc != ccbegin)
+  if (altbacktrack.cc != ccbegin)
     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
 
-  compile_hotpath(common, altfallback.cc, cc, &altfallback);
+  compile_trypath(common, altbacktrack.cc, cc, &altbacktrack);
   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
     {
     common->leavelabel = save_leavelabel;
@@ -6765,19 +6765,19 @@ while (1)
 
   add_jump(compiler, &common->accept, 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->leave = save_leave;
     return;
     }
-  set_jumps(altfallback.topfallbacks, LABEL());
+  set_jumps(altbacktrack.topbacktracks, LABEL());
 
   if (*cc != OP_ALT)
     break;
 
-  altfallback.cc = cc + 1 + LINK_SIZE;
+  altbacktrack.cc = cc + 1 + LINK_SIZE;
   cc += GET(cc, 1);
   }
 /* None of them matched. */
@@ -6809,14 +6809,14 @@ common->leavelabel = save_leavelabel;
 common->leave = save_leave;
 }
 
-#undef COMPILE_FALLBACKPATH
+#undef COMPILE_BACKTRACKPATH
 #undef CURRENT_AS
 
 void
 PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra, int mode)
 {
 struct sljit_compiler *compiler;
-fallback_common rootfallback;
+backtrack_common rootbacktrack;
 compiler_common common_data;
 compiler_common *common = &common_data;
 const pcre_uint8 *tables = re->tables;
@@ -6828,7 +6828,7 @@ void *executable_func;
 sljit_uw executable_size;
 struct sljit_label *mainloop = NULL;
 struct sljit_label *empty_match_found;
-struct sljit_label *empty_match_fallback;
+struct sljit_label *empty_match_backtrack;
 struct sljit_jump *jump;
 struct sljit_jump *reqbyte_notfound = NULL;
 struct sljit_jump *empty_match;
@@ -6839,11 +6839,11 @@ study = extra->study_data;
 if (!tables)
   tables = PRIV(default_tables);
 
-memset(&rootfallback, 0, sizeof(fallback_common));
+memset(&rootbacktrack, 0, sizeof(backtrack_common));
 memset(common, 0, sizeof(compiler_common));
-rootfallback.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
+rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
 
-common->start = rootfallback.cc;
+common->start = rootbacktrack.cc;
 common->fcc = tables + fcc_offset;
 common->lcc = (sljit_w)(tables + lcc_offset);
 common->mode = mode;
@@ -6892,13 +6892,13 @@ common->utf = (re->options & PCRE_UTF8) != 0;
 common->use_ucp = (re->options & PCRE_UCP) != 0;
 #endif
 #endif /* SUPPORT_UTF */
-ccend = bracketend(rootfallback.cc);
+ccend = bracketend(rootbacktrack.cc);
 
 /* Calculate the local space size on the stack. */
 common->ovector_start = CALL_LIMIT + sizeof(sljit_w);
 
-SLJIT_ASSERT(*rootfallback.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
-localsize = get_localspace(common, rootfallback.cc, ccend);
+SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
+localsize = get_localspace(common, rootbacktrack.cc, ccend);
 if (localsize < 0)
   return;
 
@@ -6933,10 +6933,10 @@ common->cbraptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_w);
 localsize += common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w);
 if (localsize > SLJIT_MAX_LOCAL_SIZE)
   return;
-common->localptrs = (int *)SLJIT_MALLOC((ccend - rootfallback.cc) * sizeof(int));
+common->localptrs = (int *)SLJIT_MALLOC((ccend - rootbacktrack.cc) * sizeof(int));
 if (!common->localptrs)
   return;
-memset(common->localptrs, 0, (ccend - rootfallback.cc) * sizeof(int));
+memset(common->localptrs, 0, (ccend - rootbacktrack.cc) * sizeof(int));
 set_localptrs(common, common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w), ccend);
 
 compiler = sljit_create_compiler();
@@ -7002,7 +7002,7 @@ if (mode == JIT_PARTIAL_SOFT_COMPILE)
 else if (mode == JIT_PARTIAL_HARD_COMPILE)
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
 
-compile_hotpath(common, rootfallback.cc, ccend, &rootfallback);
+compile_trypath(common, rootbacktrack.cc, ccend, &rootbacktrack);
 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   {
   sljit_free_compiler(compiler);
@@ -7031,8 +7031,8 @@ if (mode != JIT_COMPILE)
   return_with_partial_match(common, common->leavelabel);
   }
 
-empty_match_fallback = LABEL();
-compile_fallbackpath(common, rootfallback.top);
+empty_match_backtrack = LABEL();
+compile_backtrackpath(common, rootbacktrack.top);
 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   {
   sljit_free_compiler(compiler);
@@ -7040,7 +7040,7 @@ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   return;
   }
 
-SLJIT_ASSERT(rootfallback.prev == NULL);
+SLJIT_ASSERT(rootbacktrack.prev == NULL);
 
 if (mode == JIT_PARTIAL_SOFT_COMPILE)
   {
@@ -7099,12 +7099,12 @@ flush_stubs(common);
 JUMPHERE(empty_match);
 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
-CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_fallback);
+CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_backtrack);
 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
 CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found);
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
 CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found);
-JUMPTO(SLJIT_JUMP, empty_match_fallback);
+JUMPTO(SLJIT_JUMP, empty_match_backtrack);
 
 common->currententry = common->entries;
 while (common->currententry != NULL)