Irregexp-ia32: Fixed backref-matching (works, and advances current position).

src/regexp-macro-assembler-ia32.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 242 matching lines @@
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotBackReference(
     int start_reg, Label* on_no_match) {
   Label fallthrough;
   __ mov(eax, register_location(start_reg));
   __ mov(ecx, register_location(start_reg + 1));
   __ sub(ecx, Operand(eax));  // Length to check.
-  __ j(less, on_no_match);
+  BranchOrBacktrack(less, on_no_match);
   __ j(equal, &fallthrough);
-  // check that there are sufficient characters left in the input
+  // Check that there are sufficient characters left in the input.
   __ mov(ebx, edi);
   __ add(ebx, Operand(ecx));
-  __ j(greater, on_no_match);
-  __ mov(ebx, Operand(edi));
-  __ push(esi);
+  BranchOrBacktrack(greater, on_no_match);
+
+  __ mov(ebx, edi);
+  __ mov(edx, esi);
   __ add(edi, Operand(esi));
   __ add(esi, Operand(eax));
   __ rep_cmpsb();
-  __ pop(esi);
-  __ mov(edi, Operand(ebx));
-  BranchOrBacktrack(not_equal, on_no_match);
+  __ mov(esi, edx);
+  Label success;
+  __ j(equal, &success);
+  __ mov(edi, ebx);
+  BranchOrBacktrack(no_condition, on_no_match);
+
+  __ bind(&success);
+  __ sub(edi, Operand(esi));
+
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotRegistersEqual(int reg1,
                                                       int reg2,
                                                       Label* on_not_equal) {
   __ mov(eax, register_location(reg1));
   __ cmp(eax, register_location(reg2));
   BranchOrBacktrack(not_equal, on_not_equal);
@@ skipping 335 matching lines @@
 void RegExpMacroAssemblerIA32::CheckStackLimit() {
   if (FLAG_check_stack) {
     // Check for preemption first.
     Label no_preempt;
     Label retry_preempt;
     // Check for preemption.
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     __ j(above, &no_preempt, taken);
-
     __ push(edi);  // Current position.
     __ push(edx);  // Current character.
     // Restore original edi, esi.
     __ mov(edi, Operand(ebp, kBackup_edi));
     __ mov(esi, Operand(ebp, kBackup_esi));
 
     __ bind(&retry_preempt);
     // simulate stack for Runtime call.
     __ push(eax);
     __ push(Immediate(Smi::FromInt(0)));  // Dummy receiver
@@ skipping 26 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal