Revert "Update to PCRE2 10.35"

This reverts commit b419f96c626d1f9cbbba42698e947e32a0af9c4f.

This breaks the GCC build with -fcf-protection (default on Ubuntu
at least).

1 files changed, 405 insertions, 694 deletions

diff --git a/ext/pcre/pcre2lib/pcre2_jit_compile.c b/ext/pcre/pcre2lib/pcre2_jit_compile.c
index 33ad7e6553..f564127c2a 100644
--- a/ext/pcre/pcre2lib/pcre2_jit_compile.c
+++ b/ext/pcre/pcre2lib/pcre2_jit_compile.c
@@ -223,12 +223,6 @@ enum control_types {
   type_then_trap = 1
 };
 
-enum  early_fail_types {
-  type_skip = 0,
-  type_fail = 1,
-  type_fail_range = 2
-};
-
 typedef int (SLJIT_FUNC *jit_function)(jit_arguments *args);
 
 /* The following structure is the key data type for the recursive
@@ -411,8 +405,8 @@ typedef struct compiler_common {
   /* Fast forward skipping byte code pointer. */
   PCRE2_SPTR fast_forward_bc_ptr;
   /* Locals used by fast fail optimization. */
-  sljit_s32 early_fail_start_ptr;
-  sljit_s32 early_fail_end_ptr;
+  sljit_s32 fast_fail_start_ptr;
+  sljit_s32 fast_fail_end_ptr;
 
   /* Flipped and lower case tables. */
   const sljit_u8 *fcc;
@@ -482,7 +476,7 @@ typedef struct compiler_common {
 #ifdef SUPPORT_UNICODE
   BOOL utf;
   BOOL invalid_utf;
-  BOOL ucp;
+  BOOL use_ucp;
   /* Points to saving area for iref. */
   sljit_s32 iref_ptr;
   jump_list *getucd;
@@ -613,8 +607,6 @@ the start pointers when the end of the capturing group has not yet reached. */
   sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))
 #define OP2(op, dst, dstw, src1, src1w, src2, src2w) \
   sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))
-#define OP_SRC(op, src, srcw) \
-  sljit_emit_op_src(compiler, (op), (src), (srcw))
 #define LABEL() \
   sljit_emit_label(compiler)
 #define JUMP(type) \
@@ -831,7 +823,7 @@ the start pointers when the end of the capturing group has not yet reached. */
 
 static PCRE2_SPTR bracketend(PCRE2_SPTR cc)
 {
-SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NA) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
 do cc += GET(cc, 1); while (*cc == OP_ALT);
 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
 cc += 1 + LINK_SIZE;
@@ -841,7 +833,7 @@ return cc;
 static int no_alternatives(PCRE2_SPTR cc)
 {
 int count = 0;
-SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NA) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
 do
   {
   cc += GET(cc, 1);
@@ -926,8 +918,6 @@ switch(*cc)
   case OP_ASSERT_NOT:
   case OP_ASSERTBACK:
   case OP_ASSERTBACK_NOT:
-  case OP_ASSERT_NA:
-  case OP_ASSERTBACK_NA:
   case OP_ONCE:
   case OP_SCRIPT_RUN:
   case OP_BRA:
@@ -1060,7 +1050,8 @@ switch(*cc)
   return cc + 1 + 2 + cc[1];
 
   default:
-  SLJIT_UNREACHABLE();
+  /* Unsupported opcodes: OP_ASSERT_NA and OP_ASSERTBACK_NA */
+  /* SLJIT_UNREACHABLE(); */
   return NULL;
   }
 }
@@ -1070,7 +1061,6 @@ static BOOL check_opcode_types(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPT
 int count;
 PCRE2_SPTR slot;
 PCRE2_SPTR assert_back_end = cc - 1;
-PCRE2_SPTR assert_na_end = cc - 1;
 
 /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
 while (cc < ccend)
@@ -1097,14 +1087,6 @@ while (cc < ccend)
     cc += 1 + IMM2_SIZE;
     break;
 
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
-    slot = bracketend(cc);
-    if (slot > assert_na_end)
-      assert_na_end = slot;
-    cc += 1 + LINK_SIZE;
-    break;
-
     case OP_CBRAPOS:
     case OP_SCBRAPOS:
     common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
@@ -1172,9 +1154,6 @@ while (cc < ccend)
 
     case OP_COMMIT_ARG:
     case OP_PRUNE_ARG:
-    if (cc < assert_na_end)
-      return FALSE;
-    /* Fall through */
     case OP_MARK:
     if (common->mark_ptr == 0)
       {
@@ -1193,8 +1172,6 @@ while (cc < ccend)
     case OP_SKIP:
     if (cc < assert_back_end)
       common->has_skip_in_assert_back = TRUE;
-    if (cc < assert_na_end)
-      return FALSE;
     cc += 1;
     break;
 
@@ -1203,19 +1180,9 @@ while (cc < ccend)
     common->has_skip_arg = TRUE;
     if (cc < assert_back_end)
       common->has_skip_in_assert_back = TRUE;
-    if (cc < assert_na_end)
-      return FALSE;
     cc += 1 + 2 + cc[1];
     break;
 
-    case OP_PRUNE:
-    case OP_COMMIT:
-    case OP_ASSERT_ACCEPT:
-    if (cc < assert_na_end)
-      return FALSE;
-    cc++;
-    break;
-
     default:
     cc = next_opcode(common, cc);
     if (cc == NULL)
@@ -1226,355 +1193,183 @@ while (cc < ccend)
 return TRUE;
 }
 
-#define EARLY_FAIL_ENHANCE_MAX (1 + 1)
-
-/*
-start:
-  0 - skip / early fail allowed
-  1 - only early fail with range allowed
-  >1 - (start - 1) early fail is processed
-
-return: current number of iterators enhanced with fast fail
-*/
-static int detect_early_fail(compiler_common *common, PCRE2_SPTR cc, int *private_data_start, sljit_s32 depth, int start)
+static BOOL is_accelerated_repeat(PCRE2_SPTR cc)
 {
-PCRE2_SPTR next_alt;
-PCRE2_SPTR end;
-PCRE2_SPTR accelerated_start;
-int result = 0;
-int count;
-BOOL fast_forward_allowed = TRUE;
-
-SLJIT_ASSERT(*cc == OP_ONCE || *cc == OP_BRA || *cc == OP_CBRA);
-SLJIT_ASSERT(*cc != OP_CBRA || common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] != 0);
-SLJIT_ASSERT(start < EARLY_FAIL_ENHANCE_MAX);
-
-do
+switch(*cc)
   {
-  count = start;
-  next_alt = cc + GET(cc, 1);
-  cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);
+  case OP_TYPESTAR:
+  case OP_TYPEMINSTAR:
+  case OP_TYPEPLUS:
+  case OP_TYPEMINPLUS:
+  case OP_TYPEPOSSTAR:
+  case OP_TYPEPOSPLUS:
+  return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI);
 
-  while (TRUE)
-    {
-    accelerated_start = NULL;
+  case OP_STAR:
+  case OP_MINSTAR:
+  case OP_PLUS:
+  case OP_MINPLUS:
+  case OP_POSSTAR:
+  case OP_POSPLUS:
 
-    switch(*cc)
-      {
-      case OP_SOD:
-      case OP_SOM:
-      case OP_SET_SOM:
-      case OP_NOT_WORD_BOUNDARY:
-      case OP_WORD_BOUNDARY:
-      case OP_EODN:
-      case OP_EOD:
-      case OP_CIRC:
-      case OP_CIRCM:
-      case OP_DOLL:
-      case OP_DOLLM:
-      /* Zero width assertions. */
-      cc++;
-      continue;
-
-      case OP_NOT_DIGIT:
-      case OP_DIGIT:
-      case OP_NOT_WHITESPACE:
-      case OP_WHITESPACE:
-      case OP_NOT_WORDCHAR:
-      case OP_WORDCHAR:
-      case OP_ANY:
-      case OP_ALLANY:
-      case OP_ANYBYTE:
-      case OP_NOT_HSPACE:
-      case OP_HSPACE:
-      case OP_NOT_VSPACE:
-      case OP_VSPACE:
-      fast_forward_allowed = FALSE;
-      cc++;
-      continue;
+  case OP_STARI:
+  case OP_MINSTARI:
+  case OP_PLUSI:
+  case OP_MINPLUSI:
+  case OP_POSSTARI:
+  case OP_POSPLUSI:
 
-      case OP_ANYNL:
-      case OP_EXTUNI:
-      fast_forward_allowed = FALSE;
-      if (count == 0)
-        count = 1;
-      cc++;
-      continue;
-
-      case OP_NOTPROP:
-      case OP_PROP:
-      fast_forward_allowed = FALSE;
-      cc += 1 + 2;
-      continue;
-
-      case OP_CHAR:
-      case OP_CHARI:
-      case OP_NOT:
-      case OP_NOTI:
-      fast_forward_allowed = FALSE;
-      cc += 2;
-#ifdef SUPPORT_UNICODE
-      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
-#endif
-      continue;
+  case OP_NOTSTAR:
+  case OP_NOTMINSTAR:
+  case OP_NOTPLUS:
+  case OP_NOTMINPLUS:
+  case OP_NOTPOSSTAR:
+  case OP_NOTPOSPLUS:
 
-      case OP_TYPESTAR:
-      case OP_TYPEMINSTAR:
-      case OP_TYPEPLUS:
-      case OP_TYPEMINPLUS:
-      case OP_TYPEPOSSTAR:
-      case OP_TYPEPOSPLUS:
-      /* The type or prop opcode is skipped in the next iteration. */
-      cc += 1;
+  case OP_NOTSTARI:
+  case OP_NOTMINSTARI:
+  case OP_NOTPLUSI:
+  case OP_NOTMINPLUSI:
+  case OP_NOTPOSSTARI:
+  case OP_NOTPOSPLUSI:
+  return TRUE;
 
-      if (cc[0] != OP_ANYNL && cc[0] != OP_EXTUNI)
-        {
-        accelerated_start = cc - 1;
-        break;
-        }
+  case OP_CLASS:
+  case OP_NCLASS:
+#if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8
+  case OP_XCLASS:
+  cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(PCRE2_UCHAR)));
+#else
+  cc += (1 + (32 / sizeof(PCRE2_UCHAR)));
+#endif
 
-      if (count == 0)
-        count = 1;
-      fast_forward_allowed = FALSE;
-      continue;
+  switch(*cc)
+    {
+    case OP_CRSTAR:
+    case OP_CRMINSTAR:
+    case OP_CRPLUS:
+    case OP_CRMINPLUS:
+    case OP_CRPOSSTAR:
+    case OP_CRPOSPLUS:
+    return TRUE;
+    }
+  break;
+  }
+return FALSE;
+}
 
-      case OP_TYPEUPTO:
-      case OP_TYPEMINUPTO:
-      case OP_TYPEEXACT:
-      case OP_TYPEPOSUPTO:
-      cc += IMM2_SIZE;
-      /* Fall through */
-
-      case OP_TYPEQUERY:
-      case OP_TYPEMINQUERY:
-      case OP_TYPEPOSQUERY:
-      /* The type or prop opcode is skipped in the next iteration. */
-      fast_forward_allowed = FALSE;
-      if (count == 0)
-        count = 1;
-      cc += 1;
-      continue;
-
-      case OP_STAR:
-      case OP_MINSTAR:
-      case OP_PLUS:
-      case OP_MINPLUS:
-      case OP_POSSTAR:
-      case OP_POSPLUS:
-
-      case OP_STARI:
-      case OP_MINSTARI:
-      case OP_PLUSI:
-      case OP_MINPLUSI:
-      case OP_POSSTARI:
-      case OP_POSPLUSI:
-
-      case OP_NOTSTAR:
-      case OP_NOTMINSTAR:
-      case OP_NOTPLUS:
-      case OP_NOTMINPLUS:
-      case OP_NOTPOSSTAR:
-      case OP_NOTPOSPLUS:
-
-      case OP_NOTSTARI:
-      case OP_NOTMINSTARI:
-      case OP_NOTPLUSI:
-      case OP_NOTMINPLUSI:
-      case OP_NOTPOSSTARI:
-      case OP_NOTPOSPLUSI:
-      accelerated_start = cc;
-      cc += 2;
-#ifdef SUPPORT_UNICODE
-      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
-#endif
-      break;
+static SLJIT_INLINE BOOL detect_fast_forward_skip(compiler_common *common, int *private_data_start)
+{
+PCRE2_SPTR cc = common->start;
+PCRE2_SPTR end;
 
-      case OP_UPTO:
-      case OP_MINUPTO:
-      case OP_EXACT:
-      case OP_POSUPTO:
-      case OP_UPTOI:
-      case OP_MINUPTOI:
-      case OP_EXACTI:
-      case OP_POSUPTOI:
-      case OP_NOTUPTO:
-      case OP_NOTMINUPTO:
-      case OP_NOTEXACT:
-      case OP_NOTPOSUPTO:
-      case OP_NOTUPTOI:
-      case OP_NOTMINUPTOI:
-      case OP_NOTEXACTI:
-      case OP_NOTPOSUPTOI:
-      cc += IMM2_SIZE;
-      /* Fall through */
-
-      case OP_QUERY:
-      case OP_MINQUERY:
-      case OP_POSQUERY:
-      case OP_QUERYI:
-      case OP_MINQUERYI:
-      case OP_POSQUERYI:
-      case OP_NOTQUERY:
-      case OP_NOTMINQUERY:
-      case OP_NOTPOSQUERY:
-      case OP_NOTQUERYI:
-      case OP_NOTMINQUERYI:
-      case OP_NOTPOSQUERYI:
-      fast_forward_allowed = FALSE;
-      if (count == 0)
-        count = 1;
-      cc += 2;
-#ifdef SUPPORT_UNICODE
-      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
-#endif
-      continue;
+/* Skip not repeated brackets. */
+while (TRUE)
+  {
+  switch(*cc)
+    {
+    case OP_SOD:
+    case OP_SOM:
+    case OP_SET_SOM:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_EODN:
+    case OP_EOD:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    /* Zero width assertions. */
+    cc++;
+    continue;
+    }
 
-      case OP_CLASS:
-      case OP_NCLASS:
-#if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8
-      case OP_XCLASS:
-      accelerated_start = cc;
-      cc += ((*cc == OP_XCLASS) ? GET(cc, 1) : (unsigned int)(1 + (32 / sizeof(PCRE2_UCHAR))));
-#else
-      accelerated_start = cc;
-      cc += (1 + (32 / sizeof(PCRE2_UCHAR)));
-#endif
+  if (*cc != OP_BRA && *cc != OP_CBRA)
+    break;
 
-      switch (*cc)
-        {
-        case OP_CRSTAR:
-        case OP_CRMINSTAR:
-        case OP_CRPLUS:
-        case OP_CRMINPLUS:
-        case OP_CRPOSSTAR:
-        case OP_CRPOSPLUS:
-        cc++;
-        break;
+  end = cc + GET(cc, 1);
+  if (*end != OP_KET || PRIVATE_DATA(end) != 0)
+    return FALSE;
+  if (*cc == OP_CBRA)
+    {
+    if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+      return FALSE;
+    cc += IMM2_SIZE;
+    }
+  cc += 1 + LINK_SIZE;
+  }
 
-        case OP_CRRANGE:
-        case OP_CRMINRANGE:
-        case OP_CRPOSRANGE:
-        cc += 2 * IMM2_SIZE;
-        /* Fall through */
-        case OP_CRQUERY:
-        case OP_CRMINQUERY:
-        case OP_CRPOSQUERY:
-        cc++;
-        if (count == 0)
-          count = 1;
-        /* Fall through */
-        default:
-        accelerated_start = NULL;
-        fast_forward_allowed = FALSE;
-        break;
-        }
-      continue;
+if (is_accelerated_repeat(cc))
+  {
+  common->fast_forward_bc_ptr = cc;
+  common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
+  *private_data_start += sizeof(sljit_sw);
+  return TRUE;
+  }
+return FALSE;
+}
 
-      case OP_ONCE:
-      case OP_BRA:
-      case OP_CBRA:
-      end = cc + GET(cc, 1);
+static SLJIT_INLINE void detect_fast_fail(compiler_common *common, PCRE2_SPTR cc, int *private_data_start, sljit_s32 depth)
+{
+  PCRE2_SPTR next_alt;
 
-      if (*end == OP_KET && PRIVATE_DATA(end) == 0)
-        {
-        if (*cc == OP_CBRA)
-          {
-          if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
-            break;
-          cc += IMM2_SIZE;
-          }
+  SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA);
 
-        cc += 1 + LINK_SIZE;
-        continue;
-        }
+  if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+    return;
 
-      fast_forward_allowed = FALSE;
-      if (depth >= 4)
-        break;
+  next_alt = bracketend(cc) - (1 + LINK_SIZE);
+  if (*next_alt != OP_KET || PRIVATE_DATA(next_alt) != 0)
+    return;
 
-      end = bracketend(cc) - (1 + LINK_SIZE);
-      if (*end != OP_KET || PRIVATE_DATA(end) != 0)
-        break;
+  do
+    {
+    next_alt = cc + GET(cc, 1);
 
-      if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
-        break;
+    cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);
 
-      count = detect_early_fail(common, cc, private_data_start, depth + 1, count);
-      if (count < EARLY_FAIL_ENHANCE_MAX)
+    while (TRUE)
+      {
+      switch(*cc)
         {
-        cc = end + (1 + LINK_SIZE);
+        case OP_SOD:
+        case OP_SOM:
+        case OP_SET_SOM:
+        case OP_NOT_WORD_BOUNDARY:
+        case OP_WORD_BOUNDARY:
+        case OP_EODN:
+        case OP_EOD:
+        case OP_CIRC:
+        case OP_CIRCM:
+        case OP_DOLL:
+        case OP_DOLLM:
+        /* Zero width assertions. */
+        cc++;
         continue;
         }
       break;
-
-      case OP_KET:
-      SLJIT_ASSERT(PRIVATE_DATA(cc) == 0);
-      if (cc >= next_alt)
-        break;
-      cc += 1 + LINK_SIZE;
-      continue;
       }
 
-    if (accelerated_start != NULL)
-      {
-      if (count == 0)
-        {
-        count++;
-
-        if (fast_forward_allowed && *next_alt == OP_KET)
-          {
-          common->fast_forward_bc_ptr = accelerated_start;
-          common->private_data_ptrs[(accelerated_start + 1) - common->start] = ((*private_data_start) << 3) | type_skip;
-          *private_data_start += sizeof(sljit_sw);
-          }
-        else
-          {
-          common->private_data_ptrs[(accelerated_start + 1) - common->start] = ((*private_data_start) << 3) | type_fail;
-
-          if (common->early_fail_start_ptr == 0)
-            common->early_fail_start_ptr = *private_data_start;
-
-          *private_data_start += sizeof(sljit_sw);
-          common->early_fail_end_ptr = *private_data_start;
+    if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA))
+      detect_fast_fail(common, cc, private_data_start, depth - 1);
 
-          if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)
-            return EARLY_FAIL_ENHANCE_MAX;
-          }
-        }
-      else
-        {
-        common->private_data_ptrs[(accelerated_start + 1) - common->start] = ((*private_data_start) << 3) | type_fail_range;
-
-        if (common->early_fail_start_ptr == 0)
-          common->early_fail_start_ptr = *private_data_start;
-
-        *private_data_start += 2 * sizeof(sljit_sw);
-        common->early_fail_end_ptr = *private_data_start;
+    if (is_accelerated_repeat(cc))
+      {
+      common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
 
-        if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)
-          return EARLY_FAIL_ENHANCE_MAX;
-        }
+      if (common->fast_fail_start_ptr == 0)
+        common->fast_fail_start_ptr = *private_data_start;
 
-      count++;
+      *private_data_start += sizeof(sljit_sw);
+      common->fast_fail_end_ptr = *private_data_start;
 
-      if (count < EARLY_FAIL_ENHANCE_MAX)
-        continue;
+      if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)
+        return;
       }
 
-    break;
+    cc = next_alt;
     }
-
-  if (*cc != OP_ALT && *cc != OP_KET)
-    result = EARLY_FAIL_ENHANCE_MAX;
-  else if (result < count)
-    result = count;
-
-  fast_forward_allowed = FALSE;
-  cc = next_alt;
-  }
-while (*cc == OP_ALT);
-
-return result;
+  while (*cc == OP_ALT);
 }
 
 static int get_class_iterator_size(PCRE2_SPTR cc)
@@ -1791,8 +1586,6 @@ while (cc < ccend)
     case OP_ASSERT_NOT:
     case OP_ASSERTBACK:
     case OP_ASSERTBACK_NOT:
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     case OP_BRAPOS:
@@ -2370,8 +2163,6 @@ while (cc < ccend)
     case OP_ASSERT_NOT:
     case OP_ASSERTBACK:
     case OP_ASSERTBACK_NOT:
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     case OP_BRAPOS:
@@ -2696,8 +2487,6 @@ while (cc < ccend)
     case OP_ASSERT_NOT:
     case OP_ASSERTBACK:
     case OP_ASSERTBACK_NOT:
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     case OP_BRAPOS:
@@ -2871,8 +2660,8 @@ while (cc < ccend)
       }
     if (common->control_head_ptr != 0 && !control_head_found)
       {
-      private_srcw[0] = common->control_head_ptr;
-      private_count = 1;
+      shared_srcw[0] = common->control_head_ptr;
+      shared_count = 1;
       control_head_found = TRUE;
       }
     cc += 1 + 2 + cc[1];
@@ -2882,8 +2671,8 @@ while (cc < ccend)
     SLJIT_ASSERT(common->control_head_ptr != 0);
     if (!control_head_found)
       {
-      private_srcw[0] = common->control_head_ptr;
-      private_count = 1;
+      shared_srcw[0] = common->control_head_ptr;
+      shared_count = 1;
       control_head_found = TRUE;
       }
     cc++;
@@ -2967,7 +2756,7 @@ PCRE2_SPTR end = bracketend(cc);
 BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
 
 /* Assert captures then. */
-if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NA)
+if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
   current_offset = NULL;
 /* Conditional block does not. */
 if (*cc == OP_COND || *cc == OP_SCOND)
@@ -2979,7 +2768,7 @@ if (has_alternatives)
 
 while (cc < end)
   {
-  if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NA) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
+  if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
     cc = set_then_offsets(common, cc, current_offset);
   else
     {
@@ -3149,54 +2938,16 @@ else
   }
 }
 
-static SLJIT_INLINE void reset_early_fail(compiler_common *common)
+static SLJIT_INLINE void reset_fast_fail(compiler_common *common)
 {
 DEFINE_COMPILER;
-sljit_u32 size = (sljit_u32)(common->early_fail_end_ptr - common->early_fail_start_ptr);
-sljit_u32 uncleared_size;
-sljit_s32 src = SLJIT_IMM;
 sljit_s32 i;
-struct sljit_label *loop;
-
-SLJIT_ASSERT(common->early_fail_start_ptr < common->early_fail_end_ptr);
 
-if (size == sizeof(sljit_sw))
-  {
-  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->early_fail_start_ptr, SLJIT_IMM, 0);
-  return;
-  }
-
-if (sljit_get_register_index(TMP3) >= 0 && !sljit_has_cpu_feature(SLJIT_HAS_ZERO_REGISTER))
-  {
-  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
-  src = TMP3;
-  }
-
-if (size <= 6 * sizeof(sljit_sw))
-  {
-  for (i = common->early_fail_start_ptr; i < common->early_fail_end_ptr; i += sizeof(sljit_sw))
-    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, src, 0);
-  return;
-  }
-
-GET_LOCAL_BASE(TMP1, 0, common->early_fail_start_ptr);
-
-uncleared_size = ((size / sizeof(sljit_sw)) % 3) * sizeof(sljit_sw);
+SLJIT_ASSERT(common->fast_fail_start_ptr < common->fast_fail_end_ptr);
 
-OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, size - uncleared_size);
-
-loop = LABEL();
-OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), 0, src, 0);
-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));
-OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), -2 * (sljit_sw)sizeof(sljit_sw), src, 0);
-OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), -1 * (sljit_sw)sizeof(sljit_sw), src, 0);
-CMPTO(SLJIT_LESS, TMP1, 0, TMP2, 0, loop);
-
-if (uncleared_size >= sizeof(sljit_sw))
-  OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), 0, src, 0);
-
-if (uncleared_size >= 2 * sizeof(sljit_sw))
-  OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), sizeof(sljit_sw), src, 0);
+OP2(SLJIT_SUB, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+for (i = common->fast_fail_start_ptr; i < common->fast_fail_end_ptr; i += sizeof(sljit_sw))
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, TMP1, 0);
 }
 
 static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)
@@ -3442,19 +3193,16 @@ static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, PCRE2_SPTR
 unsigned int c;
 
 #ifdef SUPPORT_UNICODE
-if (common->utf || common->ucp)
+if (common->utf)
   {
-  if (common->utf)
-    {
-    GETCHAR(c, cc);
-    }
-  else
-    c = *cc;
-
+  GETCHAR(c, cc);
   if (c > 127)
+    {
     return c != UCD_OTHERCASE(c);
-
+    }
+#if PCRE2_CODE_UNIT_WIDTH != 8
   return common->fcc[c] != c;
+#endif
   }
 else
 #endif
@@ -3466,8 +3214,10 @@ static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigne
 {
 /* Returns with the othercase. */
 #ifdef SUPPORT_UNICODE
-if ((common->utf || common->ucp) && c > 127)
+if (common->utf && c > 127)
+  {
   return UCD_OTHERCASE(c);
+  }
 #endif
 return TABLE_GET(c, common->fcc, c);
 }
@@ -3481,19 +3231,15 @@ int n;
 #endif
 
 #ifdef SUPPORT_UNICODE
-if (common->utf || common->ucp)
+if (common->utf)
   {
-  if (common->utf)
-    {
-    GETCHAR(c, cc);
-    }
-  else
-    c = *cc;
-
+  GETCHAR(c, cc);
   if (c <= 127)
     oc = common->fcc[c];
   else
+    {
     oc = UCD_OTHERCASE(c);
+    }
   }
 else
   {
@@ -4337,7 +4083,7 @@ jump = JUMP(SLJIT_NOT_ZERO);
 /* Two byte sequence. */
 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3000);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump);
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
@@ -4350,7 +4096,7 @@ jump = JUMP(SLJIT_NOT_ZERO);
 /* Three byte sequence. */
 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xe0000);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Four byte sequence. */
 JUMPHERE(jump);
@@ -4360,7 +4106,7 @@ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfreadtype8(compiler_common *common)
@@ -4385,18 +4131,18 @@ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(compare);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* We only have types for characters less than 256. */
 JUMPHERE(jump);
 OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfreadchar_invalid(compiler_common *common)
@@ -4436,7 +4182,7 @@ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
 jump = JUMP(SLJIT_NOT_ZERO);
 
 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump);
 
@@ -4479,7 +4225,7 @@ if (has_cmov)
   }
 else
   exit_invalid[4] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x800);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump);
 
@@ -4508,7 +4254,7 @@ else
   exit_invalid[6] = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x100000);
 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(buffer_end_close);
 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
@@ -4525,7 +4271,7 @@ exit_invalid[8] = CMP(SLJIT_GREATER_EQUAL, TMP2, 0, SLJIT_IMM, 0x40);
 OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
 jump = JUMP(SLJIT_NOT_ZERO);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Three-byte sequence. */
 JUMPHERE(jump);
@@ -4555,7 +4301,7 @@ for (i = 0; i < 11; i++)
   sljit_set_label(exit_invalid[i], exit_invalid_label);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfreadnewline_invalid(compiler_common *common)
@@ -4586,7 +4332,7 @@ if (common->nltype != NLTYPE_ANY)
   JUMPHERE(jump[0]);
 
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-  OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   return;
   }
 
@@ -4617,14 +4363,14 @@ JUMPHERE(jump[0]);
 JUMPHERE(jump[4]);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Two byte long newline: 0x85. */
 JUMPHERE(jump[1]);
 CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0x85, skip_start);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x85);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Three byte long newlines: 0x2028 and 0x2029. */
 JUMPHERE(jump[2]);
@@ -4639,7 +4385,7 @@ CMPTO(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x40, skip_start);
 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0x2000);
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfmoveback_invalid(compiler_common *common)
@@ -4668,7 +4414,7 @@ jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x20);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 1);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Three-byte sequence. */
 JUMPHERE(jump);
@@ -4681,7 +4427,7 @@ jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x10);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 1);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Four-byte sequence. */
 JUMPHERE(jump);
@@ -4694,7 +4440,7 @@ exit_invalid[3] = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x05);
 
 exit_ok_label = LABEL();
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 1);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 /* Two-byte sequence. */
 JUMPHERE(buffer_start_close);
@@ -4724,7 +4470,7 @@ sljit_set_label(exit_invalid[5], exit_invalid_label);
 sljit_set_label(exit_invalid[6], exit_invalid_label);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(exit_invalid[4]);
 /* -2 + 4 = 2 */
@@ -4735,7 +4481,7 @@ for (i = 0; i < 4; i++)
   sljit_set_label(exit_invalid[i], exit_invalid_label);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(4));
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfpeakcharback(compiler_common *common)
@@ -4772,7 +4518,7 @@ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
 OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x80);
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfpeakcharback_invalid(compiler_common *common)
@@ -4802,7 +4548,7 @@ two_byte_entry = LABEL();
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
 /* If TMP1 is in 0x80-0xbf range, TMP1 is also increased by (0x2 << 6). */
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump[1]);
 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xc2 - 0x80);
@@ -4840,7 +4586,7 @@ if (has_cmov)
 else
   exit_invalid[3] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x800);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump[1]);
 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xe0 - 0x80);
@@ -4866,7 +4612,7 @@ else
   exit_invalid[5] = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x100000);
 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump[0]);
 OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
@@ -4889,7 +4635,7 @@ OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xe0);
 CMPTO(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0x10, three_byte_entry);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump[0]);
 exit_invalid[7] = CMP(SLJIT_GREATER, TMP2, 0, STR_PTR, 0);
@@ -4904,7 +4650,7 @@ for (i = 0; i < 8; i++)
   sljit_set_label(exit_invalid[i], exit_invalid_label);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */
@@ -4934,13 +4680,13 @@ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x10000);
 exit_invalid[2] = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x400);
 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(exit_invalid[0]);
 JUMPHERE(exit_invalid[1]);
 JUMPHERE(exit_invalid[2]);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfreadnewline_invalid(compiler_common *common)
@@ -4967,12 +4713,12 @@ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(exit_invalid[0]);
 JUMPHERE(exit_invalid[1]);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfmoveback_invalid(compiler_common *common)
@@ -4992,7 +4738,7 @@ exit_invalid[2] = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 0x400);
 
 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 1);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(exit_invalid[0]);
 JUMPHERE(exit_invalid[1]);
@@ -5000,7 +4746,7 @@ JUMPHERE(exit_invalid[2]);
 
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_utfpeakcharback_invalid(compiler_common *common)
@@ -5025,14 +4771,14 @@ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
 
 JUMPHERE(jump);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(exit_invalid[0]);
 JUMPHERE(exit_invalid[1]);
 JUMPHERE(exit_invalid[2]);
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 #endif /* PCRE2_CODE_UNIT_WIDTH == 16 */
@@ -5078,7 +4824,7 @@ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));
 OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_getucdtype(compiler_common *common)
@@ -5125,7 +4871,7 @@ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 2);
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 1);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 #endif /* SUPPORT_UNICODE */
@@ -5413,8 +5159,6 @@ while (TRUE)
     case OP_ASSERT_NOT:
     case OP_ASSERTBACK:
     case OP_ASSERTBACK_NOT:
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     cc = bracketend(cc);
     continue;
 
@@ -5714,12 +5458,7 @@ while (TRUE)
 #endif
       {
       chr = *cc;
-#ifdef SUPPORT_UNICODE
-      if (common->ucp && chr > 127)
-        othercase[0] = UCD_OTHERCASE(chr);
-      else
-#endif
-        othercase[0] = TABLE_GET(chr, common->fcc, chr);
+      othercase[0] = TABLE_GET(chr, common->fcc, chr);
       }
     }
   else
@@ -6148,8 +5887,8 @@ oc = first_char;
 if ((common->re->flags & PCRE2_FIRSTCASELESS) != 0)
   {
   oc = TABLE_GET(first_char, common->fcc, first_char);
-#if defined SUPPORT_UNICODE
-  if (first_char > 127 && (common->utf || common->ucp))
+#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8
+  if (first_char > 127 && common->utf)
     oc = UCD_OTHERCASE(first_char);
 #endif
   }
@@ -6333,80 +6072,67 @@ if (common->match_end_ptr != 0)
   OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
 }
 
-static SLJIT_INLINE jump_list *search_requested_char(compiler_common *common, PCRE2_UCHAR req_char, BOOL caseless, BOOL has_firstchar)
+static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, PCRE2_UCHAR req_char, BOOL caseless, BOOL has_firstchar)
 {
 DEFINE_COMPILER;
 struct sljit_label *loop;
 struct sljit_jump *toolong;
-struct sljit_jump *already_found;
+struct sljit_jump *alreadyfound;
 struct sljit_jump *found;
-struct sljit_jump *found_oc = NULL;
-jump_list *not_found = NULL;
+struct sljit_jump *foundoc = NULL;
+struct sljit_jump *notfound;
 sljit_u32 oc, bit;
 
 SLJIT_ASSERT(common->req_char_ptr != 0);
-OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(REQ_CU_MAX) * 100);
-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
-toolong = CMP(SLJIT_LESS, TMP2, 0, STR_END, 0);
-already_found = CMP(SLJIT_LESS, STR_PTR, 0, TMP1, 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
+OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_CU_MAX);
+toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);
+alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);
 
 if (has_firstchar)
   OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
 else
   OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
 
+loop = LABEL();
+notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);
+
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
 oc = req_char;
 if (caseless)
   {
   oc = TABLE_GET(req_char, common->fcc, req_char);
-#if defined SUPPORT_UNICODE
-  if (req_char > 127 && (common->utf || common->ucp))
+#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8
+  if (req_char > 127 && common->utf)
     oc = UCD_OTHERCASE(req_char);
 #endif
   }
-
-#ifdef JIT_HAS_FAST_REQUESTED_CHAR_SIMD
-if (JIT_HAS_FAST_REQUESTED_CHAR_SIMD)
-  {
-  not_found = fast_requested_char_simd(common, req_char, oc);
-  }
+if (req_char == oc)
+  found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
 else
-#endif
   {
-  loop = LABEL();
-  add_jump(compiler, &not_found, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0));
-
-  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
-
-  if (req_char == oc)
-    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+  bit = req_char ^ oc;
+  if (is_powerof2(bit))
+    {
+    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
+    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
+    }
   else
     {
-    bit = req_char ^ oc;
-    if (is_powerof2(bit))
-      {
-       OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
-      found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
-      }
-    else
-      {
-      found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
-      found_oc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
-      }
+    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+    foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
     }
-  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
-  JUMPTO(SLJIT_JUMP, loop);
-
-  JUMPHERE(found);
-  if (found_oc)
-    JUMPHERE(found_oc);
   }
+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+JUMPTO(SLJIT_JUMP, loop);
 
+JUMPHERE(found);
+if (foundoc)
+  JUMPHERE(foundoc);
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);
-
-JUMPHERE(already_found);
+JUMPHERE(alreadyfound);
 JUMPHERE(toolong);
-return not_found;
+return notfound;
 }
 
 static void do_revertframes(compiler_common *common)
@@ -6444,7 +6170,7 @@ JUMPTO(SLJIT_JUMP, mainloop);
 JUMPHERE(jump);
 jump = CMP(SLJIT_NOT_ZERO /* SIG_LESS */, TMP2, 0, SLJIT_IMM, 0);
 /* End of reverting values. */
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 
 JUMPHERE(jump);
 OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
@@ -6514,7 +6240,7 @@ else
 
 /* Testing char type. */
 #ifdef SUPPORT_UNICODE
-if (common->ucp)
+if (common->use_ucp)
   {
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
@@ -6560,7 +6286,7 @@ peek_char(common, READ_CHAR_MAX, SLJIT_MEM1(SLJIT_SP), LOCALS1, &invalid_utf2);
 
 valid_utf = LABEL();
 
-if (common->ucp)
+if (common->use_ucp)
   {
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
@@ -6600,7 +6326,7 @@ set_jumps(skipread_list, LABEL());
 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
 OP2(SLJIT_XOR | SLJIT_SET_Z, TMP2, 0, TMP2, 0, TMP3, 0);
-OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+sljit_emit_fast_return(compiler, TMP1, 0);
 
 #ifdef SUPPORT_UNICODE
 if (common->invalid_utf)
@@ -6612,12 +6338,12 @@ if (common->invalid_utf)
 
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, -1);
-  OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+  sljit_emit_fast_return(compiler, TMP1, 0);
 
   set_jumps(invalid_utf2, LABEL());
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   OP1(SLJIT_MOV, TMP2, 0, TMP3, 0);
-  OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+  sljit_emit_fast_return(compiler, TMP1, 0);
   }
 #endif /* SUPPORT_UNICODE */
 }
@@ -6907,7 +6633,7 @@ if (common->utf)
 #endif
 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */
 OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void check_hspace(compiler_common *common)
@@ -6946,7 +6672,7 @@ if (common->utf)
 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */
 OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void check_vspace(compiler_common *common)
@@ -6974,7 +6700,7 @@ if (common->utf)
 #endif /* SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH == [16|32] */
 OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
 
-OP_SRC(SLJIT_FAST_RETURN, RETURN_ADDR, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 }
 
 static void do_casefulcmp(compiler_common *common)
@@ -7054,7 +6780,7 @@ if (char1_reg == STR_END)
   OP1(SLJIT_MOV, char2_reg, 0, RETURN_ADDR, 0);
   }
 
-OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+sljit_emit_fast_return(compiler, TMP1, 0);
 }
 
 static void do_caselesscmp(compiler_common *common)
@@ -7152,7 +6878,7 @@ if (char2_reg == STACK_TOP)
   }
 
 OP1(SLJIT_MOV, char1_reg, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
-OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+sljit_emit_fast_return(compiler, TMP1, 0);
 }
 
 static PCRE2_SPTR byte_sequence_compare(compiler_common *common, BOOL caseless, PCRE2_SPTR cc,
@@ -7463,13 +7189,7 @@ cc = ccbegin;
 if ((cc[-1] & XCL_NOT) != 0)
   read_char(common, min, max, backtracks, READ_CHAR_UPDATE_STR_PTR);
 else
-  {
-#ifdef SUPPORT_UNICODE
-  read_char(common, min, max, (needstype || needsscript) ? backtracks : NULL, 0);
-#else /* !SUPPORT_UNICODE */
   read_char(common, min, max, NULL, 0);
-#endif /* SUPPORT_UNICODE */
-  }
 
 if ((cc[-1] & XCL_HASPROP) == 0)
   {
@@ -7555,11 +7275,16 @@ if (needstype || needsscript)
   /* Before anything else, we deal with scripts. */
   if (needsscript)
     {
-    OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 3);
-    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 2);
-    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
+// PH hacking
+      OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
+      OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
+
+      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 0);
 
-    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
+    // OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
 
     ccbegin = cc;
 
@@ -7603,19 +7328,28 @@ if (needstype || needsscript)
     {
     if (!needschar)
       {
-      OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 3);
-      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 2);
-      OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
+// PH hacking
+  OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
+  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+  OP2(SLJIT_ADD, TMP1, 0, TMP2, 0, TMP1, 0);
 
-      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 0);
+
+//      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
       }
     else
       {
-      OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+// PH hacking
+  OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+
       OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
-      OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
 
-      OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);
+  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+  OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);
+
       OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
       typereg = RETURN_ADDR;
       }
@@ -8994,13 +8728,16 @@ if (common->utf && *cc == OP_REFI)
 
   CMPTO(SLJIT_EQUAL, TMP1, 0, char1_reg, 0, loop);
 
+// PH hacking
   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
 
   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
 
-  OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+    OP2(SLJIT_SHL, TMP1, 0, TMP2, 0, SLJIT_IMM, 2);
+
   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
-  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+
+    OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
 
   OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records));
 
@@ -9860,8 +9597,7 @@ if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
         }
       else
         {
-        SLJIT_ASSERT(extrasize == 3);
-        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-1));
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
         }
       }
@@ -10193,7 +9929,7 @@ if (opcode == OP_CBRA || opcode == OP_SCBRA)
   BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
   matchingpath += IMM2_SIZE;
   }
-else if (opcode == OP_ASSERT_NA || opcode == OP_ASSERTBACK_NA || opcode == OP_ONCE || opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
+else if (opcode == OP_ONCE || opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
   {
   /* Other brackets simply allocate the next entry. */
   private_data_ptr = PRIVATE_DATA(ccbegin);
@@ -10378,7 +10114,7 @@ else if (opcode == OP_CBRA || opcode == OP_SCBRA)
     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
     }
   }
-else if (opcode == OP_ASSERT_NA || opcode == OP_ASSERTBACK_NA || opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
+else if (opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
   {
   /* Saving the previous value. */
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
@@ -10504,9 +10240,6 @@ compile_matchingpath(common, matchingpath, cc, backtrack);
 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   return NULL;
 
-if (opcode == OP_ASSERT_NA || opcode == OP_ASSERTBACK_NA)
-  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
-
 if (opcode == OP_ONCE)
   match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
 
@@ -11107,8 +10840,8 @@ backtrack_common *backtrack;
 PCRE2_UCHAR opcode;
 PCRE2_UCHAR type;
 sljit_u32 max = 0, exact;
-sljit_s32 early_fail_ptr = PRIVATE_DATA(cc + 1);
-sljit_s32 early_fail_type;
+BOOL fast_fail;
+sljit_s32 fast_str_ptr;
 BOOL charpos_enabled;
 PCRE2_UCHAR charpos_char;
 unsigned int charpos_othercasebit;
@@ -11122,27 +10855,21 @@ int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP
 int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
 int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
 int tmp_base, tmp_offset;
-#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
-BOOL use_tmp;
-#endif
 
 PUSH_BACKTRACK(sizeof(char_iterator_backtrack), cc, NULL);
 
-early_fail_type = (early_fail_ptr & 0x7);
-early_fail_ptr >>= 3;
+fast_str_ptr = PRIVATE_DATA(cc + 1);
+fast_fail = TRUE;
 
-/* During recursion, these optimizations are disabled. */
-if (common->early_fail_start_ptr == 0)
-  {
-  early_fail_ptr = 0;
-  early_fail_type = type_skip;
-  }
+SLJIT_ASSERT(common->fast_forward_bc_ptr == NULL || fast_str_ptr == 0 || cc == common->fast_forward_bc_ptr);
 
-SLJIT_ASSERT(common->fast_forward_bc_ptr != NULL || early_fail_ptr == 0
-  || (early_fail_ptr >= common->early_fail_start_ptr && early_fail_ptr <= common->early_fail_end_ptr));
+if (cc == common->fast_forward_bc_ptr)
+  fast_fail = FALSE;
+else if (common->fast_fail_start_ptr == 0)
+  fast_str_ptr = 0;
 
-if (early_fail_type == type_fail)
-  add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), early_fail_ptr));
+SLJIT_ASSERT(common->fast_forward_bc_ptr != NULL || fast_str_ptr == 0
+  || (fast_str_ptr >= common->fast_fail_start_ptr && fast_str_ptr <= common->fast_fail_end_ptr));
 
 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);
 
@@ -11157,11 +10884,13 @@ else
   tmp_offset = POSSESSIVE0;
   }
 
+if (fast_fail && fast_str_ptr != 0)
+  add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), fast_str_ptr));
+
 /* Handle fixed part first. */
 if (exact > 1)
   {
-  SLJIT_ASSERT(early_fail_ptr == 0);
-
+  SLJIT_ASSERT(fast_str_ptr == 0);
   if (common->mode == PCRE2_JIT_COMPLETE
 #ifdef SUPPORT_UNICODE
       && !common->utf
@@ -11186,31 +10915,18 @@ if (exact > 1)
     }
   }
 else if (exact == 1)
-  {
   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);
 
-  if (early_fail_type == type_fail_range)
-    {
-    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), early_fail_ptr);
-    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), early_fail_ptr + (int)sizeof(sljit_sw));
-    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, TMP2, 0);
-    OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, TMP2, 0);
-    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS_EQUAL, TMP2, 0, TMP1, 0));
-
-    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr + (int)sizeof(sljit_sw), STR_PTR, 0);
-    }
-  }
-
 switch(opcode)
   {
   case OP_STAR:
   case OP_UPTO:
-  SLJIT_ASSERT(early_fail_ptr == 0 || opcode == OP_STAR);
+  SLJIT_ASSERT(fast_str_ptr == 0 || opcode == OP_STAR);
 
   if (type == OP_ANYNL || type == OP_EXTUNI)
     {
     SLJIT_ASSERT(private_data_ptr == 0);
-    SLJIT_ASSERT(early_fail_ptr == 0);
+    SLJIT_ASSERT(fast_str_ptr == 0);
 
     allocate_stack(common, 2);
     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
@@ -11229,7 +10945,7 @@ switch(opcode)
       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);
       }
 
-    /* We cannot use TMP3 because of allocate_stack. */
+    /* We cannot use TMP3 because of this allocate_stack. */
     allocate_stack(common, 1);
     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
     JUMPTO(SLJIT_JUMP, label);
@@ -11255,8 +10971,8 @@ switch(opcode)
       OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
       process_partial_match(common);
 
-      if (early_fail_ptr != 0)
-        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_END, 0);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_END, 0);
       BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
       break;
       }
@@ -11286,8 +11002,8 @@ switch(opcode)
 
       OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
 
-      if (early_fail_ptr != 0)
-        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
       BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
       break;
       }
@@ -11314,7 +11030,7 @@ switch(opcode)
     if (charpos_enabled)
       {
       charpos_char = end[1];
-      /* Consume the OP_CHAR opcode. */
+      /* Consumpe the OP_CHAR opcode. */
       end += 2;
 #if PCRE2_CODE_UNIT_WIDTH == 8
       SLJIT_ASSERT((charpos_othercasebit >> 8) == 0);
@@ -11346,8 +11062,8 @@ switch(opcode)
       add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_ZERO));
       }
     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);
-    if (early_fail_ptr != 0)
-      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
     JUMPHERE(jump);
 
     detect_partial_match(common, &backtrack->topbacktracks);
@@ -11360,7 +11076,6 @@ switch(opcode)
       allocate_stack(common, 2);
     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
     OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
-
     if (opcode == OP_UPTO)
       {
       OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
@@ -11370,55 +11085,53 @@ switch(opcode)
     /* Search the last instance of charpos_char. */
     label = LABEL();
     compile_char1_matchingpath(common, type, cc, &no_match, FALSE);
-    if (early_fail_ptr != 0)
-      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
     detect_partial_match(common, &no_match);
     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
     if (charpos_othercasebit != 0)
       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, charpos_othercasebit);
-
     if (opcode == OP_STAR)
       {
       CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);
       OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
-      JUMPTO(SLJIT_JUMP, label);
       }
     else
       {
       jump = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char);
       OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
       JUMPHERE(jump);
+      }
+
+    if (opcode == OP_UPTO)
+      {
       OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
       JUMPTO(SLJIT_NOT_ZERO, label);
       }
+    else
+      JUMPTO(SLJIT_JUMP, label);
 
     set_jumps(no_match, LABEL());
-    OP2(SLJIT_ADD, STR_PTR, 0, base, offset0, SLJIT_IMM, IN_UCHARS(1));
+    OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
     }
-  else
+#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
+  else if (common->utf)
     {
     if (private_data_ptr == 0)
       allocate_stack(common, 2);
 
+    OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
     OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
-#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
-    use_tmp = (!HAS_VIRTUAL_REGISTERS && opcode == OP_STAR);
-    SLJIT_ASSERT(!use_tmp || tmp_base == TMP3);
 
-    if (common->utf)
-      OP1(SLJIT_MOV, use_tmp ? TMP3 : base, use_tmp ? 0 : offset0, STR_PTR, 0);
-#endif
     if (opcode == OP_UPTO)
       OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
 
     detect_partial_match(common, &no_match);
     label = LABEL();
-    compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
-#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
-    if (common->utf)
-      OP1(SLJIT_MOV, use_tmp ? TMP3 : base, use_tmp ? 0 : offset0, STR_PTR, 0);
-#endif
+    compile_char1_matchingpath(common, type, cc, &no_match, FALSE);
+    OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
 
     if (opcode == OP_UPTO)
       {
@@ -11429,29 +11142,39 @@ switch(opcode)
     detect_partial_match_to(common, label);
     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
 
-    set_jumps(no_char1_match, LABEL());
-#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
-    if (common->utf)
-      {
-      set_jumps(no_match, LABEL());
-      if (use_tmp)
-        {
-        OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
-        OP1(SLJIT_MOV, base, offset0, TMP3, 0);
-        }
-      else
-        OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
-      }
-    else
+    set_jumps(no_match, LABEL());
+    OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+    }
 #endif
+  else
+    {
+    if (private_data_ptr == 0)
+      allocate_stack(common, 2);
+
+    OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+    if (opcode == OP_UPTO)
+      OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+
+    detect_partial_match(common, &no_match);
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
+    if (opcode == OP_UPTO)
       {
-      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-      set_jumps(no_match, LABEL());
-      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+      add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));
       }
 
-    if (early_fail_ptr != 0)
-      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+    detect_partial_match_to(common, label);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+    set_jumps(no_char1_match, LABEL());
+    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    set_jumps(no_match, LABEL());
+    OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
     }
 
   BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
@@ -11462,12 +11185,12 @@ switch(opcode)
     allocate_stack(common, 1);
   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
-  if (early_fail_ptr != 0)
-    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+  if (fast_str_ptr != 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
   break;
 
   case OP_MINUPTO:
-  SLJIT_ASSERT(early_fail_ptr == 0);
+  SLJIT_ASSERT(fast_str_ptr == 0);
   if (private_data_ptr == 0)
     allocate_stack(common, 2);
   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
@@ -11477,7 +11200,7 @@ switch(opcode)
 
   case OP_QUERY:
   case OP_MINQUERY:
-  SLJIT_ASSERT(early_fail_ptr == 0);
+  SLJIT_ASSERT(fast_str_ptr == 0);
   if (private_data_ptr == 0)
     allocate_stack(common, 1);
   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
@@ -11498,8 +11221,8 @@ switch(opcode)
     {
     OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
     process_partial_match(common);
-    if (early_fail_ptr != 0)
-      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_END, 0);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_END, 0);
     break;
     }
 
@@ -11515,17 +11238,16 @@ switch(opcode)
 
     set_jumps(no_match, LABEL());
     OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
-    if (early_fail_ptr != 0)
+    if (fast_str_ptr != 0)
       {
-      if (!HAS_VIRTUAL_REGISTERS && tmp_base == TMP3)
-        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, TMP3, 0);
+      if (tmp_base == TMP3)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, TMP3, 0);
       else
-        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
       }
     break;
     }
 #endif
-
   detect_partial_match(common, &no_match);
   label = LABEL();
   compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
@@ -11535,12 +11257,12 @@ switch(opcode)
   set_jumps(no_char1_match, LABEL());
   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   set_jumps(no_match, LABEL());
-  if (early_fail_ptr != 0)
-    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
+  if (fast_str_ptr != 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
   break;
 
   case OP_POSUPTO:
-  SLJIT_ASSERT(early_fail_ptr == 0);
+  SLJIT_ASSERT(fast_str_ptr == 0);
 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
   if (common->utf)
     {
@@ -11576,6 +11298,9 @@ switch(opcode)
       process_partial_match(common);
       JUMPHERE(jump);
       }
+
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
     break;
     }
 
@@ -11595,7 +11320,7 @@ switch(opcode)
   break;
 
   case OP_POSQUERY:
-  SLJIT_ASSERT(early_fail_ptr == 0);
+  SLJIT_ASSERT(fast_str_ptr == 0);
   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
@@ -11970,8 +11695,6 @@ while (cc < ccend)
     count_match(common);
     break;
 
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     case OP_BRA:
@@ -12509,7 +12232,6 @@ else if (has_alternatives)
 
     SLJIT_ASSERT(CURRENT_AS(bracket_backtrack)->u.matching_put_label);
     sljit_set_put_label(CURRENT_AS(bracket_backtrack)->u.matching_put_label, LABEL());
-    sljit_emit_op0(compiler, SLJIT_ENDBR);
     }
   else
     next_alt = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
@@ -12576,9 +12298,6 @@ if (has_alternatives)
       if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
         return;
 
-      if (opcode == OP_ASSERT_NA || opcode == OP_ASSERTBACK_NA)
-        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
-
       if (opcode == OP_SCRIPT_RUN)
         match_script_run_common(common, private_data_ptr, current);
       }
@@ -12660,10 +12379,7 @@ if (has_alternatives)
           }
         }
       else
-        {
         sljit_set_put_label(put_label, LABEL());
-        sljit_emit_op0(compiler, SLJIT_ENDBR);
-        }
       }
 
     COMPILE_BACKTRACKINGPATH(current->top);
@@ -12711,7 +12427,7 @@ if (offset != 0)
     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
     }
   }
-else if (opcode == OP_ASSERT_NA || opcode == OP_ASSERTBACK_NA || opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
+else if (opcode == OP_SCRIPT_RUN || opcode == OP_SBRA || opcode == OP_SCOND)
   {
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(0));
   free_stack(common, 1);
@@ -13059,8 +12775,6 @@ while (current)
     compile_assert_backtrackingpath(common, current);
     break;
 
-    case OP_ASSERT_NA:
-    case OP_ASSERTBACK_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     case OP_BRA:
@@ -13158,7 +12872,7 @@ jump_list *match = NULL;
 struct sljit_jump *next_alt = NULL;
 struct sljit_jump *accept_exit = NULL;
 struct sljit_label *quit;
-struct sljit_put_label *put_label = NULL;
+struct sljit_put_label *put_label;
 
 /* Recurse captures then. */
 common->then_trap = NULL;
@@ -13255,7 +12969,6 @@ while (1)
         {
         sljit_emit_ijump(compiler, SLJIT_JUMP, TMP1, 0);
         sljit_set_put_label(put_label, LABEL());
-        sljit_emit_op0(compiler, SLJIT_ENDBR);
         }
       else
         next_alt = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
@@ -13264,10 +12977,7 @@ while (1)
       free_stack(common, has_accept ? 2 : 1);
     }
   else if (alt_max > 3)
-    {
     sljit_set_put_label(put_label, LABEL());
-    sljit_emit_op0(compiler, SLJIT_ENDBR);
-    }
   else
     {
     JUMPHERE(next_alt);
@@ -13301,7 +13011,7 @@ copy_recurse_data(common, ccbegin, ccend, recurse_copy_private_to_global, local_
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(local_size - 1));
 free_stack(common, private_data_size + local_size);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-OP_SRC(SLJIT_FAST_RETURN, TMP2, 0);
+sljit_emit_fast_return(compiler, TMP2, 0);
 
 if (common->quit != NULL)
   {
@@ -13326,7 +13036,7 @@ if (has_accept)
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(local_size - 1));
   free_stack(common, private_data_size + local_size);
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-  OP_SRC(SLJIT_FAST_RETURN, TMP2, 0);
+  sljit_emit_fast_return(compiler, TMP2, 0);
   }
 
 if (common->accept != NULL)
@@ -13350,7 +13060,7 @@ copy_recurse_data(common, ccbegin, ccend, recurse_swap_global, local_size, priva
 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), STACK(local_size - 1));
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 1);
-OP_SRC(SLJIT_FAST_RETURN, TMP2, 0);
+sljit_emit_fast_return(compiler, TMP2, 0);
 }
 
 #undef COMPILE_BACKTRACKINGPATH
@@ -13382,9 +13092,9 @@ struct sljit_label *reset_match_label;
 struct sljit_label *quit_label;
 struct sljit_jump *jump;
 struct sljit_jump *minlength_check_failed = NULL;
+struct sljit_jump *reqbyte_notfound = NULL;
 struct sljit_jump *empty_match = NULL;
 struct sljit_jump *end_anchor_failed = NULL;
-jump_list *reqcu_not_found = NULL;
 
 SLJIT_ASSERT(tables);
 
@@ -13412,8 +13122,8 @@ common->read_only_data_head = NULL;
 common->fcc = tables + fcc_offset;
 common->lcc = (sljit_sw)(tables + lcc_offset);
 common->mode = mode;
-common->might_be_empty = (re->minlength == 0) || (re->flags & PCRE2_MATCH_EMPTY);
-common->allow_empty_partial = (re->max_lookbehind > 0) || (re->flags & PCRE2_MATCH_EMPTY);
+common->might_be_empty = re->minlength == 0;
+common->allow_empty_partial = (re->max_lookbehind > 0) || (re->flags & PCRE2_MATCH_EMPTY) != 0;
 common->nltype = NLTYPE_FIXED;
 switch(re->newline_convention)
   {
@@ -13450,7 +13160,7 @@ common->alt_circumflex = (re->overall_options & PCRE2_ALT_CIRCUMFLEX) != 0;
 #ifdef SUPPORT_UNICODE
 /* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
 common->utf = (re->overall_options & PCRE2_UTF) != 0;
-common->ucp = (re->overall_options & PCRE2_UCP) != 0;
+common->use_ucp = (re->overall_options & PCRE2_UCP) != 0;
 if (common->utf)
   {
   if (common->nltype == NLTYPE_ANY)
@@ -13562,10 +13272,13 @@ memset(common->private_data_ptrs, 0, total_length * sizeof(sljit_s32));
 
 private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);
 set_private_data_ptrs(common, &private_data_size, ccend);
-if ((re->overall_options & PCRE2_ANCHORED) == 0 && (re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0 && !common->has_skip_in_assert_back)
-  detect_early_fail(common, common->start, &private_data_size, 0, 0);
+if ((re->overall_options & PCRE2_ANCHORED) == 0 && (re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0)
+  {
+  if (!detect_fast_forward_skip(common, &private_data_size) && !common->has_skip_in_assert_back)
+    detect_fast_fail(common, common->start, &private_data_size, 4);
+  }
 
-SLJIT_ASSERT(common->early_fail_start_ptr <= common->early_fail_end_ptr);
+SLJIT_ASSERT(common->fast_fail_start_ptr <= common->fast_fail_end_ptr);
 
 if (private_data_size > SLJIT_MAX_LOCAL_SIZE)
   {
@@ -13609,8 +13322,8 @@ OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_sta
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH, TMP1, 0);
 
-if (common->early_fail_start_ptr < common->early_fail_end_ptr)
-  reset_early_fail(common);
+if (common->fast_fail_start_ptr < common->fast_fail_end_ptr)
+  reset_fast_fail(common);
 
 if (mode == PCRE2_JIT_PARTIAL_SOFT)
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);
@@ -13647,7 +13360,7 @@ if (mode == PCRE2_JIT_COMPLETE && re->minlength > 0 && (re->overall_options & PC
   minlength_check_failed = CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0);
   }
 if (common->req_char_ptr != 0)
-  reqcu_not_found = search_requested_char(common, (PCRE2_UCHAR)(re->last_codeunit), (re->flags & PCRE2_LASTCASELESS) != 0, (re->flags & PCRE2_FIRSTSET) != 0);
+  reqbyte_notfound = search_requested_char(common, (PCRE2_UCHAR)(re->last_codeunit), (re->flags & PCRE2_LASTCASELESS) != 0, (re->flags & PCRE2_FIRSTSET) != 0);
 
 /* Store the current STR_PTR in OVECTOR(0). */
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);
@@ -13656,7 +13369,7 @@ OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH);
 if (common->capture_last_ptr != 0)
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, 0);
 if (common->fast_forward_bc_ptr != NULL)
-  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), PRIVATE_DATA(common->fast_forward_bc_ptr + 1) >> 3, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), PRIVATE_DATA(common->fast_forward_bc_ptr + 1), STR_PTR, 0);
 
 if (common->start_ptr != OVECTOR(0))
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_ptr, STR_PTR, 0);
@@ -13703,8 +13416,6 @@ if (common->abort != NULL)
   set_jumps(common->abort, common->abort_label);
 if (minlength_check_failed != NULL)
   SET_LABEL(minlength_check_failed, common->abort_label);
-
-sljit_emit_op0(compiler, SLJIT_SKIP_FRAMES_BEFORE_RETURN);
 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 
 if (common->failed_match != NULL)
@@ -13757,7 +13468,7 @@ if ((re->overall_options & PCRE2_ANCHORED) == 0 && common->match_end_ptr != 0)
   }
 
 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP),
-    (common->fast_forward_bc_ptr != NULL) ? (PRIVATE_DATA(common->fast_forward_bc_ptr + 1) >> 3) : common->start_ptr);
+    (common->fast_forward_bc_ptr != NULL) ? (PRIVATE_DATA(common->fast_forward_bc_ptr + 1)) : common->start_ptr);
 
 if ((re->overall_options & PCRE2_ANCHORED) == 0)
   {
@@ -13782,8 +13493,8 @@ if ((re->overall_options & PCRE2_ANCHORED) == 0)
   }
 
 /* No more remaining characters. */
-if (reqcu_not_found != NULL)
-  set_jumps(reqcu_not_found, LABEL());
+if (reqbyte_notfound != NULL)
+  JUMPHERE(reqbyte_notfound);
 
 if (mode == PCRE2_JIT_PARTIAL_SOFT)
   CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);
@@ -13808,8 +13519,8 @@ if (common->might_be_empty)
   }
 
 common->fast_forward_bc_ptr = NULL;
-common->early_fail_start_ptr = 0;
-common->early_fail_end_ptr = 0;
+common->fast_fail_start_ptr = 0;
+common->fast_fail_end_ptr = 0;
 common->currententry = common->entries;
 common->local_quit_available = TRUE;
 quit_label = common->quit_label;
@@ -13852,7 +13563,7 @@ OP1(SLJIT_MOV, TMP2, 0, STACK_LIMIT, 0);
 OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_RETURN_REG, 0);
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
-OP_SRC(SLJIT_FAST_RETURN, TMP1, 0);
+sljit_emit_fast_return(compiler, TMP1, 0);
 
 /* Allocation failed. */
 JUMPHERE(jump);
@@ -14031,6 +13742,11 @@ pcre2_jit_compile(pcre2_code *code, uint32_t options)
 {
 pcre2_real_code *re = (pcre2_real_code *)code;
 
+#ifdef SUPPORT_JIT
+executable_functions *functions = (executable_functions *)re->executable_jit;
+static int executable_allocator_is_working = 0;
+#endif
+
 if (code == NULL)
   return PCRE2_ERROR_NULL;
 
@@ -14063,11 +13779,6 @@ actions are needed:
      avoid compiler warnings.
 */
 
-#ifdef SUPPORT_JIT
-executable_functions *functions = (executable_functions *)re->executable_jit;
-static int executable_allocator_is_working = 0;
-#endif
-
 if ((options & PCRE2_JIT_INVALID_UTF) != 0)
   {
   if ((re->overall_options & PCRE2_MATCH_INVALID_UTF) == 0)