Improve greedy repeat support (#639)

Author: zherczeg

src/pcre2_jit_compile.c

@@ -1769,7 +1769,7 @@ switch(*cc)
   if (max == 0)
     return (*cc == OP_CRRANGE) ? 2 : 1;
   max -= min;
-  if (max > 2)
+  if (max > (*cc == OP_CRRANGE ? 0 : 1))
     max = 2;
   return max;
 
@@ -10467,10 +10467,12 @@ else
   if (*max == 0)
     {
     SLJIT_ASSERT(*exact > 1);
-    if (*opcode == OP_CRPOSRANGE)
+    if (*opcode == OP_CRRANGE)
+      *opcode = OP_UPTO;
+    else if (*opcode == OP_CRPOSRANGE)
       *opcode = OP_POSUPTO;
     else
-      *opcode -= OP_CRRANGE - OP_STAR;
+      *opcode = OP_MINSTAR;
     return cc;
     }
 
@@ -10480,12 +10482,14 @@ else
   else
     {
     SLJIT_ASSERT(*exact > 0 || *max > 1);
-    if (*opcode == OP_CRPOSRANGE)
+    if (*opcode == OP_CRRANGE)
+      *opcode = OP_UPTO;
+    else if (*opcode == OP_CRPOSRANGE)
       *opcode = OP_POSUPTO;
     else if (*max == 1)
-      *opcode -= OP_CRRANGE - OP_QUERY;
+      *opcode = OP_MINQUERY;
     else
-      *opcode -= OP_CRRANGE - OP_UPTO;
+      *opcode = OP_MINUPTO;
     }
   return cc;
   }
@@ -10586,7 +10590,7 @@ else
   }
 
 /* Handle fixed part first. */
-if (opcode != OP_POSUPTO)
+if (opcode != OP_UPTO && opcode != OP_POSUPTO)
   {
   if (exact > 1)
     {
@@ -10646,11 +10650,9 @@ if (early_fail_type == type_fail_range)
 switch(opcode)
   {
   case OP_UPTO:
-  /* Exact is ignored for upto. */
-  exact = 0;
-  /* Fall through */
   case OP_STAR:
   SLJIT_ASSERT(early_fail_ptr == 0 || opcode == OP_STAR);
+  max += exact;
 
   if (type == OP_EXTUNI)
     {
@@ -10665,6 +10667,9 @@ switch(opcode)
       }
     else
       {
+      /* If OP_EXTUNI is present, it has a separate EXACT opcode. */
+      SLJIT_ASSERT(exact == 0);
+
       allocate_stack(common, 2);
       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
@@ -10726,6 +10731,9 @@ switch(opcode)
     else
 #endif
       {
+      /* If OP_ALLANY is present, it has a separate EXACT opcode. */
+      SLJIT_ASSERT(exact == 0);
+
       if (private_data_ptr == 0)
         allocate_stack(common, 2);
 
@@ -10794,71 +10802,86 @@ switch(opcode)
       if (private_data_ptr == 0)
         allocate_stack(common, 2);
 
-      use_tmp = (!HAS_VIRTUAL_REGISTERS && opcode == OP_STAR);
+      use_tmp = (opcode == OP_STAR);
 
       if (use_tmp)
         {
-        OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, 0);
-        OP1(SLJIT_MOV, base, offset0, tmp_base, tmp_offset);
+        OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
+        OP1(SLJIT_MOV, base, offset0, TMP3, 0);
         }
       else
         {
-        OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-        OP1(SLJIT_MOV, base, offset0, TMP1, 0);
-        OP1(SLJIT_MOV, base, offset1, TMP1, 0);
-        if (opcode == OP_UPTO)
-          OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max + 1);
+        OP1(SLJIT_MOV, base, offset1, COUNT_MATCH, 0);
+        OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_IMM, 0);
+        OP1(SLJIT_MOV, base, offset0, COUNT_MATCH, 0);
+        OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, exact == max ? 0 : (max + 1));
         }
 
       /* Search the first instance of charpos_char. */
-      if (exact == 1)
-        {
-        SLJIT_ASSERT(opcode == OP_STAR);
+      if (exact > 0)
         detect_partial_match(common, &no_match);
-        }
       else
         jump = JUMP(SLJIT_JUMP);
 
       label = LABEL();
+
       if (opcode == OP_UPTO)
         {
-        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 (exact == max)
+          OP2(SLJIT_ADD, TMP3, 0, TMP3, 0, SLJIT_IMM, 1);
+        else
+          {
+          OP2(SLJIT_SUB | SLJIT_SET_Z, TMP3, 0, TMP3, 0, SLJIT_IMM, 1);
+          add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));
+          }
         }
+
       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 (exact != 1)
+      if (exact == 0)
         JUMPHERE(jump);
 
       detect_partial_match(common, &no_match);
+
+      if (opcode == OP_UPTO && exact > 0)
+        {
+        if (exact == max)
+          CMPTO(SLJIT_LESS, TMP3, 0, SLJIT_IMM, exact, label);
+        else
+          CMPTO(SLJIT_GREATER, TMP3, 0, SLJIT_IMM, (max + 1) - exact, label);
+        }
+
       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);
       CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);
 
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
       if (use_tmp)
         {
-        OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
-        OP2U(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, SLJIT_IMM, 0);
-        SELECT(SLJIT_EQUAL, tmp_base, STR_PTR, 0, tmp_base);
+        OP2U(SLJIT_SUB | SLJIT_SET_Z, TMP3, 0, SLJIT_IMM, 0);
+        SELECT(SLJIT_EQUAL, TMP3, STR_PTR, 0, TMP3);
         }
       else
         {
-        OP1(SLJIT_MOV, TMP2, 0, base, offset1);
-        OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
-        OP2U(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_IMM, 0);
-        SELECT(SLJIT_EQUAL, TMP2, STR_PTR, 0, TMP2);
-        OP1(SLJIT_MOV, base, offset1, TMP2, 0);
+        OP2U(SLJIT_SUB | SLJIT_SET_Z, COUNT_MATCH, 0, SLJIT_IMM, 0);
+        SELECT(SLJIT_EQUAL, COUNT_MATCH, STR_PTR, 0, COUNT_MATCH);
         }
       JUMPTO(SLJIT_JUMP, label);
 
       set_jumps(no_match, LABEL());
       OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
       if (use_tmp)
-        OP1(SLJIT_MOV, base, offset1, tmp_base, tmp_offset);
+        OP1(SLJIT_MOV, base, offset1, TMP3, 0);
+      else
+        {
+        OP1(SLJIT_MOV, TMP1, 0, base, offset1);
+        OP1(SLJIT_MOV, base, offset1, COUNT_MATCH, 0);
+        OP1(SLJIT_MOV, COUNT_MATCH, 0, TMP1, 0);
+        }
 
       add_jump(compiler, &backtrack->own_backtracks, CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0));
 
@@ -10872,60 +10895,110 @@ switch(opcode)
   if (private_data_ptr == 0)
     allocate_stack(common, 2);
 
-  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);
+  use_tmp = (opcode == OP_STAR);
 
   if (common->utf)
-    OP1(SLJIT_MOV, use_tmp ? TMP3 : base, use_tmp ? 0 : offset0, STR_PTR, 0);
+    {
+    if (!use_tmp)
+      OP1(SLJIT_MOV, base, offset0, COUNT_MATCH, 0);
+
+    OP1(SLJIT_MOV, use_tmp ? TMP3 : COUNT_MATCH, 0, STR_PTR, 0);
+    }
 #endif
+
   if (opcode == OP_UPTO)
-    OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+    OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, exact == max ? -(sljit_sw)exact : (sljit_sw)max);
 
-  detect_partial_match(common, &no_match);
-  label = LABEL();
-  compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
+  if (opcode == OP_UPTO && exact > 0)
+    {
+    label = LABEL();
+    detect_partial_match(common, &no_match);
+    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);
+    if (common->utf)
+      OP1(SLJIT_MOV, use_tmp ? TMP3 : COUNT_MATCH, 0, STR_PTR, 0);
 #endif
 
-  if (opcode == OP_UPTO)
-    {
-    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 (exact == max)
+      {
+      OP2(SLJIT_ADD | SLJIT_SET_Z, TMP3, 0, TMP3, 0, SLJIT_IMM, 1);
+      JUMPTO(SLJIT_NOT_ZERO, label);
+      }
+    else
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_Z, TMP3, 0, TMP3, 0, SLJIT_IMM, 1);
+      add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));
+      CMPTO(SLJIT_NOT_EQUAL, TMP3, 0, SLJIT_IMM, max - exact, label);
+      }
+
+    OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+    JUMPTO(SLJIT_JUMP, label);
     }
+  else
+    {
+    OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
 
-  detect_partial_match_to(common, label);
-  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    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 : COUNT_MATCH, 0, STR_PTR, 0);
+#endif
+
+    if (opcode == OP_UPTO)
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_Z, TMP3, 0, TMP3, 0, SLJIT_IMM, 1);
+      add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));
+      }
+
+    detect_partial_match_to(common, label);
+    }
 
-  set_jumps(no_char1_match, LABEL());
 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
   if (common->utf)
     {
+    set_jumps(no_char1_match, LABEL());
     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);
+      {
+      OP1(SLJIT_MOV, STR_PTR, 0, COUNT_MATCH, 0);
+      OP1(SLJIT_MOV, COUNT_MATCH, 0, base, offset0);
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      }
     }
   else
 #endif
     {
+    if (opcode != OP_UPTO || exact == 0)
+      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 (exact == 1)
+  if (opcode == OP_UPTO)
     {
-    SLJIT_ASSERT(opcode == OP_STAR);
-    add_jump(compiler, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, CMP(SLJIT_EQUAL, base, offset1, STR_PTR, 0));
+    if (exact > 0)
+      {
+      if (max == exact)
+        jump = CMP(SLJIT_GREATER_EQUAL, TMP3, 0, SLJIT_IMM, -(sljit_sw)exact);
+      else
+        jump = CMP(SLJIT_GREATER, TMP3, 0, SLJIT_IMM, max - exact);
+
+      add_jump(compiler, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, jump);
+      }
     }
+  else if (exact == 1)
+    add_jump(compiler, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, CMP(SLJIT_EQUAL, base, offset1, STR_PTR, 0));
 
   if (early_fail_ptr != 0)
     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), early_fail_ptr, STR_PTR, 0);
@@ -11052,8 +11125,8 @@ switch(opcode)
 
   case OP_POSUPTO:
   SLJIT_ASSERT(early_fail_ptr == 0);
-
   max += exact;
+
 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32
   if (type == OP_EXTUNI || common->utf)
 #else
@@ -11738,8 +11811,7 @@ switch(opcode)
       OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
       JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
 
-      if (opcode == OP_STAR && exact == 1)
-        set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());
+      set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());
       }
 
     JUMPHERE(jump);

testdata/testinput1

@@ -7043,6 +7043,23 @@ $/x
     ab
     a
 
+/^(.{3,6}!)+$/s
+  abc!defghi!
+  abcdef!ghi!
+  abc!def!ghi!jkl!
+  ab!cd!
+\= Expect no match
+  abcd!ef!
+  ab!cdefg!
+
+/[a-z]{5,}b|x/
+  abcdefghbijb
+  abcdefghbij
+  abcdeb
+\= Expect no match
+  abcdb
+  abcdefghijk
+
 # --------------
 
 # End of testinput1 

testdata/testinput4

@@ -1856,6 +1856,19 @@
 /[z\x{017f}]+/i,utf
     \x{0053}\x{0073}\x{017f}
 
+/^[a-z\x{500}-\x{1000}]{3,}[a-h]|x/utf
+    ab\x{600}ijklmh
+    ab\x{600}hijklm
+\= Expect no match
+    ab\x{600}ijklm
+
+/^[a-z\x{500}-\x{1000}]{4,7}[a-h]|x/utf
+    ab\x{600}\x{700}ijkh
+    ab\x{600}\x{700}hijkl
+\= Expect no match
+    ab\x{600}\x{700}ijklh
+    ab\x{600}h\x{700}ijklmh
+
 # --------------------------------------
 
 /(ΣΆΜΟΣ) \1/i,utf