* Fixes and tweaks to regexp-ia32.

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 33 matching lines @@
  *         Please notice that this is the byte offset, not the character offset!
  * - esi : end of input (points to byte after last character in input).
  * - ebp : points to the location above the registers on the stack,
  *         as if by the "enter <register_count>" opcode.
  * - esp : points to tip of backtracking stack.
  *
  * The registers eax, ebx and ecx are free to use for computations.
  *
  * Each call to a public method should retain this convention.
  * The stack will have the following structure:
+ *       - at_start           (if 1, start at start of string, if 0, don't)
  *       - int* capture_array (int[num_saved_registers_], for output).
  *       - end of input       (index of end of string, relative to *string_base)
  *       - start of input     (index of first character in string, relative
  *                            to *string_base)
  *       - void** string_base (location of a handle containing the string)
  *       - return address
  *       - backup of esi
  *       - backup of edi
+ *       - backup of ebx
  * ebp-> - old ebp
  *       - register 0  ebp[-4]  (Only positions must be stored in the first
  *       - register 1  ebp[-8]   num_saved_registers_ registers)
  *       - ...
  *
  * The first num_saved_registers_ registers are initialized to point to
  * "character -1" in the string (i.e., char_size() bytes before the first
  * character of the string). The remaining registers starts out as garbage.
  *
  * The data up to the return address must be placed there by the calling
  * code, e.g., by calling the code as cast to:
  * bool (*match)(String** string_base,
  *               int start_offset,
  *               int end_offset,
- *               int* capture_output_array)
+ *               int* capture_output_array,
+ *               bool at_start)
  */
 
 #define __ masm_->
 
 RegExpMacroAssemblerIA32::RegExpMacroAssemblerIA32(
     Mode mode,
     int registers_to_save)
     : masm_(new MacroAssembler(NULL, kRegExpCodeSize)),
       constants_(kRegExpConstantsSize),
       mode_(mode),
@@ skipping 41 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::Bind(Label* label) {
   __ bind(label);
 }
 
 void RegExpMacroAssemblerIA32::CheckBitmap(uc16 start,
                                            Label* bitmap,
                                            Label* on_zero) {
   UNREACHABLE();
   ReadCurrentChar(eax);

[Erik Corry, 2008/11/30 19:39:27]

The intention of this operation is that it operates on an already loaded current
character, so it is wrong to load it here.

[Lasse Reichstein, 2008/12/04 15:18:37]

The ReadCurrentChar function merely moves the already loaded  value into a
register. It's a simple abstraction on top of the "edx" register, but probably
one that has outlived its usefullness. I have reworded it to "mov(eax,
current_character())", where "current_character()" is just a more readable way
of saying "edx".

   __ sub(Operand(eax), Immediate(start));
   __ cmp(eax, 64);  // FIXME: 64 = length_of_bitmap_in_bits.
   BranchOrBacktrack(greater_equal, on_zero);
   __ mov(ebx, eax);
   __ shr(ebx, 3);
   // TODO(lrn): Where is the bitmap stored? Pass the bitmap as argument instead.
   // __ mov(ecx, position_of_bitmap);
   __ movzx_b(ebx, Operand(ecx, ebx, times_1, 0));
   __ and_(eax, (1<<3)-1);
   __ bt(Operand(ebx), eax);
   __ j(carry, on_zero);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacter(uc16 c, Label* on_equal) {
   __ cmp(edx, c);
   BranchOrBacktrack(equal, on_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacterGT(uc16 limit, Label* on_greater) {
   __ cmp(edx, limit);
   BranchOrBacktrack(greater, on_greater);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotAtStart(Label* on_not_at_start) {
-  UNIMPLEMENTED();
+  __ test(Operand(ebp, kAtStart), Immediate(0xffffffff));

[Erik Corry, 2008/11/30 19:39:27]

I think a cmp against zero is less confusing here.

[Lasse Reichstein, 2008/12/04 15:18:37]

Done.

+  BranchOrBacktrack(equal, on_not_at_start);
+  __ mov(eax, Operand(ebp, kInputEndOffset));
+  __ add(eax, Operand(edi));
+  __ cmp(eax, Operand(ebp, kInputStartOffset));
+  BranchOrBacktrack(not_equal, on_not_at_start);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacterLT(uc16 limit, Label* on_less) {
   __ cmp(edx, limit);
   BranchOrBacktrack(less, on_less);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacters(Vector<const uc16> str,
                                                int cp_offset,
                                                Label* on_failure) {
   int byte_length = str.length() * char_size();
   int byte_offset = cp_offset * char_size();
-  __ mov(ebx, edi);
-  __ add(Operand(ebx), Immediate(byte_offset + byte_length));
-  BranchOrBacktrack(greater_equal, on_failure);
+  __ cmp(Operand(edi), Immediate(-(byte_offset + byte_length)));
+  BranchOrBacktrack(greater, on_failure);
+
+  if (str.length() <= kMaxInlineStringTests) {
+    for (int i = 0; i < str.length(); i++) {
+      if (mode_ == ASCII) {
+        __ cmpb(Operand(esi, edi, times_1, byte_offset + i),
+                static_cast<int8_t>(str[i]));
+      } else {
+        ASSERT(mode_ == UC16);
+        __ cmpw(Operand(esi, edi, times_1, byte_offset + i * sizeof(uc16)),
+                Immediate(str[i]));
+      }
+      __ j(not_equal, on_failure);
+    }
+    return;
+  }
 
   ArraySlice constant_buffer = constants_.GetBuffer(str.length(), char_size());
   if (mode_ == ASCII) {
     for (int i = 0; i < str.length(); i++) {
       constant_buffer.at<char>(i) = static_cast<char>(str[i]);
     }
   } else {
     memcpy(constant_buffer.location(),
            str.start(),
            str.length() * sizeof(uc16));
   }
 
   __ mov(eax, edi);
   __ mov(ebx, esi);
   __ lea(edi, Operand(esi, edi, times_1, byte_offset));
   LoadConstantBufferAddress(esi, &constant_buffer);
-  __ mov(ecx, str.length() * char_size());
-  __ rep_cmpsb();
+  __ mov(ecx, str.length());
+  if (char_size() == 1) {
+    __ rep_cmpsb();
+  } else {
+    ASSERT(char_size() == 2);
+    __ rep_cmpsw();
+  }
   __ mov(esi, ebx);
   __ mov(edi, eax);
   BranchOrBacktrack(not_equal, on_failure);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCurrentPosition(int register_index,
                                                     Label* on_equal) {
   __ cmp(edi, register_location(register_index));
   BranchOrBacktrack(equal, on_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotBackReferenceIgnoreCase(
     int start_reg, Label* on_no_match) {
-  UNIMPLEMENTED();
+  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);
+  __ j(equal, &fallthrough);
+
+  UNIMPLEMENTED();  // TODO(lrn): Call runtime function to do test.
+
+  __ 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(equal, &fallthrough);  // Covers the case where it's not bound (-1,-1).
+  __ j(less, on_no_match);
+  __ j(equal, &fallthrough);
+  // 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);
   __ add(edi, Operand(esi));
   __ add(esi, Operand(eax));
-  if (char_size() > 0) {
-    ASSERT(char_size() == 2);
-    __ add(ecx, Operand(ecx));
-  }
   __ rep_cmpsb();
   __ pop(esi);
   __ mov(edi, Operand(ebx));
   BranchOrBacktrack(not_equal, on_no_match);
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotRegistersEqual(int reg1,
                                                       int reg2,
                                                       Label* on_not_equal) {
   __ mov(eax, register_location(reg1));
-  __ mov(ecx, register_location(reg2));
-  __ cmp(ecx, Operand(eax));
+  __ cmp(eax, register_location(reg2));
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotCharacter(uc16 c, Label* on_not_equal) {
   __ cmp(edx, c);
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotCharacterAfterOr(uc16 c,
                                                         uc16 mask,
                                                         Label* on_not_equal) {
-  __ mov(eax, Operand(edx));
+  ReadCurrentChar(eax);

[Erik Corry, 2008/11/30 19:39:27]

This operation should also use the current character already loaded.

   __ or_(eax, mask);
   __ cmp(eax, c);
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckNotCharacterAfterMinusOr(
     uc16 c,
     uc16 mask,
     Label* on_not_equal) {
   __ lea(eax, Operand(edx, -mask));
   __ or_(eax, mask);
   __ cmp(eax, c);
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::DispatchHalfNibbleMap(
     uc16 start,
     Label* half_nibble_map,
     const Vector<Label*>& destinations) {
+  UNIMPLEMENTED();
   ReadCurrentChar(eax);

[Erik Corry, 2008/11/30 19:39:27]

And again.

   __ sub(Operand(eax), Immediate(start));
 
   __ mov(ecx, eax);
   __ shr(eax, 2);
   // FIXME: ecx must hold address of map
   __ movzx_b(eax, Operand(ecx, eax, times_1, 0));
   __ and_(ecx, 0x03);
   __ add(ecx, Operand(ecx));
   __ shr(eax);  // Shift right cl times
 
@@ skipping 15 matching lines @@
   __ bind(&case_3);
   // Case 3:
   __ jmp(destinations[3]);
 }
 
 
 void RegExpMacroAssemblerIA32::DispatchByteMap(
     uc16 start,
     Label* byte_map,
     const Vector<Label*>& destinations) {
+  UNIMPLEMENTED();
+
   Label fallthrough;
   ReadCurrentChar(eax);

[Erik Corry, 2008/11/30 19:39:27]

Ditto.

   __ sub(Operand(eax), Immediate(start));
   __ cmp(eax, 64);  // FIXME: 64 = size of map. Found somehow??
   __ j(greater_equal, &fallthrough);
   // TODO(lrn): ecx must hold address of map
   __ movzx_b(eax, Operand(ecx, eax, times_1, 0));
   // jump table: jump to destinations[eax];
 
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::DispatchHighByteMap(
     byte start,
     Label* byte_map,
     const Vector<Label*>& destinations) {
-  UNREACHABLE();
+  UNIMPLEMENTED();
 
   Label fallthrough;
   ReadCurrentChar(eax);

[Erik Corry, 2008/11/30 19:39:27]

Ditto

   __ shr(eax, 8);
   __ sub(Operand(eax), Immediate(start));
   __ cmp(eax, destinations.length() - start);
   __ j(greater_equal, &fallthrough);
 
   // TODO(lrn) jumptable: jump to destinations[eax]
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::EmitOrLink(Label* label) {
-  UNREACHABLE();  // Has no use.
+  UNIMPLEMENTED();  // Has no use.
 }
 
 
 void RegExpMacroAssemblerIA32::Fail() {
   __ xor_(eax, Operand(eax));  // zero eax.
   __ jmp(&exit_label_);
 }
 
 
 Handle<Object> RegExpMacroAssemblerIA32::GetCode() {
@@ skipping 24 matching lines @@
     // Fill saved registers with initial value = start offset - 1
     __ mov(ecx, -num_saved_registers_);
     __ mov(eax, Operand(edi));
     __ sub(Operand(eax), Immediate(char_size()));
     Label init_loop;
     __ bind(&init_loop);
     __ mov(Operand(ebp, ecx, times_4, +0), eax);
     __ inc(ecx);
     __ j(not_equal, &init_loop);
   }
+  // Load previous char as initial value of current-character.
+  Label at_start;
+  __ test(Operand(ebp, kAtStart), Immediate(0xffffffff));
+  __ j(not_equal, &at_start);
+  ReadChar(edx, -1);
   __ jmp(&start_label_);
+  __ bind(&at_start);
+  __ mov(edx, '\n');
+  __ jmp(&start_label_);
+
 
   // Exit code:
   __ bind(&success_label_);
   if (num_saved_registers_ > 0) {
     // copy captures to output
     __ mov(ebx, Operand(ebp, kRegisterOutput));
     __ mov(ecx, Operand(ebp, kInputEndOffset));
     __ sub(ecx, Operand(ebp, kInputStartOffset));
     for (int i = 0; i < num_saved_registers_; i++) {
       __ mov(eax, register_location(i));
@@ skipping 23 matching lines @@
   LOG(CodeCreateEvent("RegExp", *code, "(Compiled RegExp)"));
   return Handle<Object>::cast(code);
 }
 
 
 void RegExpMacroAssemblerIA32::GoTo(Label* to) {
   __ jmp(to);
 }
 
 
-
 void RegExpMacroAssemblerIA32::IfRegisterGE(int reg,
                                             int comparand,
                                             Label* if_ge) {
   __ cmp(register_location(reg), Immediate(comparand));
   BranchOrBacktrack(greater_equal, if_ge);
 }
 
 
-
 void RegExpMacroAssemblerIA32::IfRegisterLT(int reg,
                                             int comparand,
                                             Label* if_lt) {
   __ cmp(register_location(reg), Immediate(comparand));
   BranchOrBacktrack(less, if_lt);
 }
 
 
-
 RegExpMacroAssembler::IrregexpImplementation
     RegExpMacroAssemblerIA32::Implementation() {
   return kIA32Implementation;
 }
 
 
-
 void RegExpMacroAssemblerIA32::LoadCurrentCharacter(int cp_offset,
                                                     Label* on_end_of_input) {
   ASSERT(cp_offset >= 0);
   ASSERT(cp_offset < (1<<30));  // Be sane! (And ensure negation works)
   __ cmp(edi, -cp_offset * char_size());
   BranchOrBacktrack(greater_equal, on_end_of_input);
   ReadChar(edx, cp_offset);
 }
 
 
 void RegExpMacroAssemblerIA32::PopCurrentPosition() {
   __ pop(edi);
 }
 
 
 void RegExpMacroAssemblerIA32::PopRegister(int register_index) {
-  RecordRegister(register_index);
   __ pop(register_location(register_index));
 }
 
 
 void RegExpMacroAssemblerIA32::PushBacktrack(Label* label) {
   // CheckStackLimit();  // Not ready yet.
   __ push(label, RelocInfo::NONE);
 }
 
 
@@ skipping 12 matching lines @@
 }
 
 
 void RegExpMacroAssemblerIA32::ReadStackPointerFromRegister(int reg) {
   __ mov(esp, register_location(reg));
 }
 
 
 void RegExpMacroAssemblerIA32::SetRegister(int register_index, int to) {
   ASSERT(register_index >= num_saved_registers_);  // Reserved for positions!
-  RecordRegister(register_index);
   __ mov(register_location(register_index), Immediate(to));
 }
 
 
 void RegExpMacroAssemblerIA32::Succeed() {
   __ jmp(&success_label_);
 }
 
 
-void RegExpMacroAssemblerIA32::WriteCurrentPositionToRegister(
-    int register_index) {
-  RecordRegister(register_index);
-  __ mov(register_location(register_index), edi);
+void RegExpMacroAssemblerIA32::WriteCurrentPositionToRegister(int reg) {
+  __ mov(register_location(reg), edi);
 }
 
 void RegExpMacroAssemblerIA32::WriteStackPointerToRegister(int reg) {
   __ mov(register_location(reg), esp);
 }
 
 
 // Private methods:
 
-Operand RegExpMacroAssemblerIA32::register_location(
-    int register_index) {
+Operand RegExpMacroAssemblerIA32::register_location(int register_index) {
   ASSERT(register_index < (1<<30));
+  if (num_registers_ <= register_index) {
+    num_registers_ = register_index + 1;
+  }
   return Operand(ebp, -(register_index + 1) * kPointerSize);
 }
 
 
 size_t RegExpMacroAssemblerIA32::char_size() {
   return static_cast<size_t>(mode_);
 }
 
 
 void RegExpMacroAssemblerIA32::BranchOrBacktrack(Condition condition,
@@ skipping 64 matching lines @@
     __ pop(edi);
     __ mov(esi, Operand(ebp, kInputBuffer));
     __ mov(esi, Operand(esi, 0));
     __ add(esi, Operand(ebp, kInputEndOffset));
 
     __ bind(&no_preempt);
   }
 }
 
 
-void RegExpMacroAssemblerIA32::RecordRegister(int register_index) {
-  if (register_index >= num_registers_) {
-    num_registers_ = register_index + 1;
-  }
-}
-
-
 void RegExpMacroAssemblerIA32::ReadChar(Register destination, int offset) {
   if (mode_ == ASCII) {
     __ movzx_b(destination, Operand(esi, edi, times_1, offset));
     return;
   }
   ASSERT(mode_ == UC16);
-  __ movzx_w(destination, Operand(esi, edi, times_1, offset * 2));
+  __ movzx_w(destination, Operand(esi, edi, times_1, offset * sizeof(uc16)));
 }
 
 
 void RegExpMacroAssemblerIA32::ReadCurrentChar(Register destination) {
   __ mov(destination, edx);
 }
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal