* Better factoring of ARM/IA32 code in irregexp.

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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <string.h>
 #include "v8.h"
 #include "log.h"
 #include "ast.h"
 #include "macro-assembler.h"
+#include "regexp-macro-assembler.h"
+#include "macro-assembler-ia32.h"
 #include "regexp-macro-assembler-ia32.h"
 
 namespace v8 { namespace internal {
+
 /*
  * This assembler uses the following register assignment convention
  * - edx : current character. Must be loaded using LoadCurrentCharacter
  *         before using any of the dispatch methods.
  * - edi : current position in input, as negative offset from end of string.
  *         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.
@@ skipping 302 matching lines @@
 
 
 Handle<Object> RegExpMacroAssemblerIA32::GetCode() {
   // Finalize code - write the entry point code now we know how many
   // registers we need.
 
   // Entry code:
   __ bind(&entry_label_);
   __ push(esi);
   __ push(edi);
-  __ enter(Immediate(num_registers_ * sizeof(uint32_t)));
+  __ enter(Immediate(num_registers_ * kPointerSize));
   __ mov(esi, Operand(ebp, kInputEndOffset));
   __ mov(edi, Operand(ebp, kInputStartOffset));
   __ sub(edi, Operand(esi));
   __ mov(edx, Operand(ebp, kInputBuffer));
   __ mov(edx, Operand(edx, 0));
   __ add(esi, Operand(edx));
   if (num_saved_registers_ > 0) {
     // Fill saved registers with initial value = start offset - 1
     __ mov(ecx, -num_saved_registers_);
     __ mov(eax, Operand(edi));
@@ skipping 12 matching lines @@
     // 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));
       __ add(eax, Operand(ecx));  // Convert to index from start, not end.
       if (char_size() == 2) {
         __ shr(eax);
       }
-      __ mov(Operand(ebx, i * sizeof(int32_t)), eax);
+      __ mov(Operand(ebx, i * kPointerSize), eax);
     }
   }
   __ mov(eax, Immediate(1));
 
   __ bind(&exit_label_);
   __ leave();
   __ pop(edi);
   __ pop(esi);
   __ ret(0);
 
@@ skipping 107 matching lines @@
 void RegExpMacroAssemblerIA32::WriteStackPointerToRegister(int reg) {
   __ mov(register_location(reg), esp);
 }
 
 
 // Private methods:
 
 Operand RegExpMacroAssemblerIA32::register_location(
     int register_index) {
   ASSERT(register_index < (1<<30));
-  return Operand(ebp, -(register_index + 1) * sizeof(uint32_t));
+  return Operand(ebp, -(register_index + 1) * kPointerSize);
 }
 
 
 size_t RegExpMacroAssemblerIA32::char_size() {
   return static_cast<size_t>(mode_);
 }
 
 
 void RegExpMacroAssemblerIA32::BranchOrBacktrack(Condition condition,
                                                  Label* to) {
@@ skipping 92 matching lines @@
 }
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
-}}
+}}  // namespace v8::internal