Introduce x87 port

src/x87/regexp-macro-assembler-x87.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_X87
 
 #include "cpu-profiler.h"
 #include "unicode.h"
 #include "log.h"
 #include "regexp-stack.h"
 #include "macro-assembler.h"
 #include "regexp-macro-assembler.h"
-#include "ia32/regexp-macro-assembler-ia32.h"
+#include "x87/regexp-macro-assembler-x87.h"
 
 namespace v8 {
 namespace internal {
 
 #ifndef V8_INTERPRETED_REGEXP
 /*
  * This assembler uses the following register assignment convention
  * - edx : Current character.  Must be loaded using LoadCurrentCharacter
  *         before using any of the dispatch methods.  Temporarily stores the
  *         index of capture start after a matching pass for a global regexp.
@@ skipping 44 matching lines @@
  *              Address start,
  *              Address end,
  *              int* capture_output_array,
  *              bool at_start,
  *              byte* stack_area_base,
  *              bool direct_call)
  */
 
 #define __ ACCESS_MASM(masm_)
 
-RegExpMacroAssemblerIA32::RegExpMacroAssemblerIA32(
+RegExpMacroAssemblerX87::RegExpMacroAssemblerX87(
     Mode mode,
     int registers_to_save,
     Zone* zone)
     : NativeRegExpMacroAssembler(zone),
       masm_(new MacroAssembler(zone->isolate(), NULL, kRegExpCodeSize)),
       mode_(mode),
       num_registers_(registers_to_save),
       num_saved_registers_(registers_to_save),
       entry_label_(),
       start_label_(),
       success_label_(),
       backtrack_label_(),
       exit_label_() {
   ASSERT_EQ(0, registers_to_save % 2);
   __ jmp(&entry_label_);   // We'll write the entry code later.
   __ bind(&start_label_);  // And then continue from here.
 }
 
 
-RegExpMacroAssemblerIA32::~RegExpMacroAssemblerIA32() {
+RegExpMacroAssemblerX87::~RegExpMacroAssemblerX87() {
   delete masm_;
   // Unuse labels in case we throw away the assembler without calling GetCode.
   entry_label_.Unuse();
   start_label_.Unuse();
   success_label_.Unuse();
   backtrack_label_.Unuse();
   exit_label_.Unuse();
   check_preempt_label_.Unuse();
   stack_overflow_label_.Unuse();
 }
 
 
-int RegExpMacroAssemblerIA32::stack_limit_slack()  {
+int RegExpMacroAssemblerX87::stack_limit_slack()  {
   return RegExpStack::kStackLimitSlack;
 }
 
 
-void RegExpMacroAssemblerIA32::AdvanceCurrentPosition(int by) {
+void RegExpMacroAssemblerX87::AdvanceCurrentPosition(int by) {
   if (by != 0) {
     __ add(edi, Immediate(by * char_size()));
   }
 }
 
 
-void RegExpMacroAssemblerIA32::AdvanceRegister(int reg, int by) {
+void RegExpMacroAssemblerX87::AdvanceRegister(int reg, int by) {
   ASSERT(reg >= 0);
   ASSERT(reg < num_registers_);
   if (by != 0) {
     __ add(register_location(reg), Immediate(by));
   }
 }
 
 
-void RegExpMacroAssemblerIA32::Backtrack() {
+void RegExpMacroAssemblerX87::Backtrack() {
   CheckPreemption();
   // Pop Code* offset from backtrack stack, add Code* and jump to location.
   Pop(ebx);
   __ add(ebx, Immediate(masm_->CodeObject()));
   __ jmp(ebx);
 }
 
 
-void RegExpMacroAssemblerIA32::Bind(Label* label) {
+void RegExpMacroAssemblerX87::Bind(Label* label) {
   __ bind(label);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacter(uint32_t c, Label* on_equal) {
+void RegExpMacroAssemblerX87::CheckCharacter(uint32_t c, Label* on_equal) {
   __ cmp(current_character(), c);
   BranchOrBacktrack(equal, on_equal);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacterGT(uc16 limit, Label* on_greater) {
+void RegExpMacroAssemblerX87::CheckCharacterGT(uc16 limit, Label* on_greater) {
   __ cmp(current_character(), limit);
   BranchOrBacktrack(greater, on_greater);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckAtStart(Label* on_at_start) {
+void RegExpMacroAssemblerX87::CheckAtStart(Label* on_at_start) {
   Label not_at_start;
   // Did we start the match at the start of the string at all?
   __ cmp(Operand(ebp, kStartIndex), Immediate(0));
   BranchOrBacktrack(not_equal, &not_at_start);
   // If we did, are we still at the start of the input?
   __ lea(eax, Operand(esi, edi, times_1, 0));
   __ cmp(eax, Operand(ebp, kInputStart));
   BranchOrBacktrack(equal, on_at_start);
   __ bind(&not_at_start);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotAtStart(Label* on_not_at_start) {
+void RegExpMacroAssemblerX87::CheckNotAtStart(Label* on_not_at_start) {
   // Did we start the match at the start of the string at all?
   __ cmp(Operand(ebp, kStartIndex), Immediate(0));
   BranchOrBacktrack(not_equal, on_not_at_start);
   // If we did, are we still at the start of the input?
   __ lea(eax, Operand(esi, edi, times_1, 0));
   __ cmp(eax, Operand(ebp, kInputStart));
   BranchOrBacktrack(not_equal, on_not_at_start);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacterLT(uc16 limit, Label* on_less) {
+void RegExpMacroAssemblerX87::CheckCharacterLT(uc16 limit, Label* on_less) {
   __ cmp(current_character(), limit);
   BranchOrBacktrack(less, on_less);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckGreedyLoop(Label* on_equal) {
+void RegExpMacroAssemblerX87::CheckGreedyLoop(Label* on_equal) {
   Label fallthrough;
   __ cmp(edi, Operand(backtrack_stackpointer(), 0));
   __ j(not_equal, &fallthrough);
   __ add(backtrack_stackpointer(), Immediate(kPointerSize));  // Pop.
   BranchOrBacktrack(no_condition, on_equal);
   __ bind(&fallthrough);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotBackReferenceIgnoreCase(
+void RegExpMacroAssemblerX87::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
   __ mov(edx, register_location(start_reg));  // Index of start of capture
   __ mov(ebx, register_location(start_reg + 1));  // Index of end of capture
   __ sub(ebx, edx);  // Length of capture.
 
   // The length of a capture should not be negative. This can only happen
   // if the end of the capture is unrecorded, or at a point earlier than
   // the start of the capture.
@@ skipping 116 matching lines @@
     // Check if function returned non-zero for success or zero for failure.
     __ or_(eax, eax);
     BranchOrBacktrack(zero, on_no_match);
     // On success, increment position by length of capture.
     __ add(edi, ebx);
   }
   __ bind(&fallthrough);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotBackReference(
+void RegExpMacroAssemblerX87::CheckNotBackReference(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
   Label success;
   Label fail;
 
   // Find length of back-referenced capture.
   __ mov(edx, register_location(start_reg));
   __ mov(eax, register_location(start_reg + 1));
   __ sub(eax, edx);  // Length to check.
@@ skipping 43 matching lines @@
   // Move current character position to position after match.
   __ mov(edi, ecx);
   __ sub(edi, esi);
   // Restore backtrack stackpointer.
   __ pop(backtrack_stackpointer());
 
   __ bind(&fallthrough);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotCharacter(uint32_t c,
+void RegExpMacroAssemblerX87::CheckNotCharacter(uint32_t c,
                                                  Label* on_not_equal) {
   __ cmp(current_character(), c);
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacterAfterAnd(uint32_t c,
+void RegExpMacroAssemblerX87::CheckCharacterAfterAnd(uint32_t c,
                                                       uint32_t mask,
                                                       Label* on_equal) {
   if (c == 0) {
     __ test(current_character(), Immediate(mask));
   } else {
     __ mov(eax, mask);
     __ and_(eax, current_character());
     __ cmp(eax, c);
   }
   BranchOrBacktrack(equal, on_equal);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotCharacterAfterAnd(uint32_t c,
+void RegExpMacroAssemblerX87::CheckNotCharacterAfterAnd(uint32_t c,
                                                          uint32_t mask,
                                                          Label* on_not_equal) {
   if (c == 0) {
     __ test(current_character(), Immediate(mask));
   } else {
     __ mov(eax, mask);
     __ and_(eax, current_character());
     __ cmp(eax, c);
   }
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckNotCharacterAfterMinusAnd(
+void RegExpMacroAssemblerX87::CheckNotCharacterAfterMinusAnd(
     uc16 c,
     uc16 minus,
     uc16 mask,
     Label* on_not_equal) {
   ASSERT(minus < String::kMaxUtf16CodeUnit);
   __ lea(eax, Operand(current_character(), -minus));
   if (c == 0) {
     __ test(eax, Immediate(mask));
   } else {
     __ and_(eax, mask);
     __ cmp(eax, c);
   }
   BranchOrBacktrack(not_equal, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacterInRange(
+void RegExpMacroAssemblerX87::CheckCharacterInRange(
     uc16 from,
     uc16 to,
     Label* on_in_range) {
   __ lea(eax, Operand(current_character(), -from));
   __ cmp(eax, to - from);
   BranchOrBacktrack(below_equal, on_in_range);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckCharacterNotInRange(
+void RegExpMacroAssemblerX87::CheckCharacterNotInRange(
     uc16 from,
     uc16 to,
     Label* on_not_in_range) {
   __ lea(eax, Operand(current_character(), -from));
   __ cmp(eax, to - from);
   BranchOrBacktrack(above, on_not_in_range);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckBitInTable(
+void RegExpMacroAssemblerX87::CheckBitInTable(
     Handle<ByteArray> table,
     Label* on_bit_set) {
   __ mov(eax, Immediate(table));
   Register index = current_character();
   if (mode_ != ASCII || kTableMask != String::kMaxOneByteCharCode) {
     __ mov(ebx, kTableSize - 1);
     __ and_(ebx, current_character());
     index = ebx;
   }
   __ cmpb(FieldOperand(eax, index, times_1, ByteArray::kHeaderSize), 0);
   BranchOrBacktrack(not_equal, on_bit_set);
 }
 
 
-bool RegExpMacroAssemblerIA32::CheckSpecialCharacterClass(uc16 type,
+bool RegExpMacroAssemblerX87::CheckSpecialCharacterClass(uc16 type,
                                                           Label* on_no_match) {
   // Range checks (c in min..max) are generally implemented by an unsigned
   // (c - min) <= (max - min) check
   switch (type) {
   case 's':
     // Match space-characters
     if (mode_ == ASCII) {
       // One byte space characters are '\t'..'\r', ' ' and \u00a0.
       Label success;
       __ cmp(current_character(), ' ');
@@ skipping 100 matching lines @@
     }
     return true;
   }
   // No custom implementation (yet): s(UC16), S(UC16).
   default:
     return false;
   }
 }
 
 
-void RegExpMacroAssemblerIA32::Fail() {
+void RegExpMacroAssemblerX87::Fail() {
   STATIC_ASSERT(FAILURE == 0);  // Return value for failure is zero.
   if (!global()) {
     __ Move(eax, Immediate(FAILURE));
   }
   __ jmp(&exit_label_);
 }
 
 
-Handle<HeapObject> RegExpMacroAssemblerIA32::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerX87::GetCode(Handle<String> source) {
   Label return_eax;
   // Finalize code - write the entry point code now we know how many
   // registers we need.
 
   // Entry code:
   __ bind(&entry_label_);
 
   // Tell the system that we have a stack frame.  Because the type is MANUAL, no
   // code is generated.
   FrameScope scope(masm_, StackFrame::MANUAL);
@@ skipping 272 matching lines @@
   masm_->GetCode(&code_desc);
   Handle<Code> code =
       isolate()->factory()->NewCode(code_desc,
                                     Code::ComputeFlags(Code::REGEXP),
                                     masm_->CodeObject());
   PROFILE(isolate(), RegExpCodeCreateEvent(*code, *source));
   return Handle<HeapObject>::cast(code);
 }
 
 
-void RegExpMacroAssemblerIA32::GoTo(Label* to) {
+void RegExpMacroAssemblerX87::GoTo(Label* to) {
   BranchOrBacktrack(no_condition, to);
 }
 
 
-void RegExpMacroAssemblerIA32::IfRegisterGE(int reg,
+void RegExpMacroAssemblerX87::IfRegisterGE(int reg,
                                             int comparand,
                                             Label* if_ge) {
   __ cmp(register_location(reg), Immediate(comparand));
   BranchOrBacktrack(greater_equal, if_ge);
 }
 
 
-void RegExpMacroAssemblerIA32::IfRegisterLT(int reg,
+void RegExpMacroAssemblerX87::IfRegisterLT(int reg,
                                             int comparand,
                                             Label* if_lt) {
   __ cmp(register_location(reg), Immediate(comparand));
   BranchOrBacktrack(less, if_lt);
 }
 
 
-void RegExpMacroAssemblerIA32::IfRegisterEqPos(int reg,
+void RegExpMacroAssemblerX87::IfRegisterEqPos(int reg,
                                                Label* if_eq) {
   __ cmp(edi, register_location(reg));
   BranchOrBacktrack(equal, if_eq);
 }
 
 
 RegExpMacroAssembler::IrregexpImplementation
-    RegExpMacroAssemblerIA32::Implementation() {
-  return kIA32Implementation;
+    RegExpMacroAssemblerX87::Implementation() {
+  return kX87Implementation;
 }
 
 
-void RegExpMacroAssemblerIA32::LoadCurrentCharacter(int cp_offset,
+void RegExpMacroAssemblerX87::LoadCurrentCharacter(int cp_offset,
                                                     Label* on_end_of_input,
                                                     bool check_bounds,
                                                     int characters) {
   ASSERT(cp_offset >= -1);      // ^ and \b can look behind one character.
   ASSERT(cp_offset < (1<<30));  // Be sane! (And ensure negation works)
   if (check_bounds) {
     CheckPosition(cp_offset + characters - 1, on_end_of_input);
   }
   LoadCurrentCharacterUnchecked(cp_offset, characters);
 }
 
 
-void RegExpMacroAssemblerIA32::PopCurrentPosition() {
+void RegExpMacroAssemblerX87::PopCurrentPosition() {
   Pop(edi);
 }
 
 
-void RegExpMacroAssemblerIA32::PopRegister(int register_index) {
+void RegExpMacroAssemblerX87::PopRegister(int register_index) {
   Pop(eax);
   __ mov(register_location(register_index), eax);
 }
 
 
-void RegExpMacroAssemblerIA32::PushBacktrack(Label* label) {
+void RegExpMacroAssemblerX87::PushBacktrack(Label* label) {
   Push(Immediate::CodeRelativeOffset(label));
   CheckStackLimit();
 }
 
 
-void RegExpMacroAssemblerIA32::PushCurrentPosition() {
+void RegExpMacroAssemblerX87::PushCurrentPosition() {
   Push(edi);
 }
 
 
-void RegExpMacroAssemblerIA32::PushRegister(int register_index,
+void RegExpMacroAssemblerX87::PushRegister(int register_index,
                                             StackCheckFlag check_stack_limit) {
   __ mov(eax, register_location(register_index));
   Push(eax);
   if (check_stack_limit) CheckStackLimit();
 }
 
 
-void RegExpMacroAssemblerIA32::ReadCurrentPositionFromRegister(int reg) {
+void RegExpMacroAssemblerX87::ReadCurrentPositionFromRegister(int reg) {
   __ mov(edi, register_location(reg));
 }
 
 
-void RegExpMacroAssemblerIA32::ReadStackPointerFromRegister(int reg) {
+void RegExpMacroAssemblerX87::ReadStackPointerFromRegister(int reg) {
   __ mov(backtrack_stackpointer(), register_location(reg));
   __ add(backtrack_stackpointer(), Operand(ebp, kStackHighEnd));
 }
 
-void RegExpMacroAssemblerIA32::SetCurrentPositionFromEnd(int by)  {
+void RegExpMacroAssemblerX87::SetCurrentPositionFromEnd(int by)  {
   Label after_position;
   __ cmp(edi, -by * char_size());
   __ j(greater_equal, &after_position, Label::kNear);
   __ mov(edi, -by * char_size());
   // On RegExp code entry (where this operation is used), the character before
   // the current position is expected to be already loaded.
   // We have advanced the position, so it's safe to read backwards.
   LoadCurrentCharacterUnchecked(-1, 1);
   __ bind(&after_position);
 }
 
 
-void RegExpMacroAssemblerIA32::SetRegister(int register_index, int to) {
+void RegExpMacroAssemblerX87::SetRegister(int register_index, int to) {
   ASSERT(register_index >= num_saved_registers_);  // Reserved for positions!
   __ mov(register_location(register_index), Immediate(to));
 }
 
 
-bool RegExpMacroAssemblerIA32::Succeed() {
+bool RegExpMacroAssemblerX87::Succeed() {
   __ jmp(&success_label_);
   return global();
 }
 
 
-void RegExpMacroAssemblerIA32::WriteCurrentPositionToRegister(int reg,
+void RegExpMacroAssemblerX87::WriteCurrentPositionToRegister(int reg,
                                                               int cp_offset) {
   if (cp_offset == 0) {
     __ mov(register_location(reg), edi);
   } else {
     __ lea(eax, Operand(edi, cp_offset * char_size()));
     __ mov(register_location(reg), eax);
   }
 }
 
 
-void RegExpMacroAssemblerIA32::ClearRegisters(int reg_from, int reg_to) {
+void RegExpMacroAssemblerX87::ClearRegisters(int reg_from, int reg_to) {
   ASSERT(reg_from <= reg_to);
   __ mov(eax, Operand(ebp, kInputStartMinusOne));
   for (int reg = reg_from; reg <= reg_to; reg++) {
     __ mov(register_location(reg), eax);
   }
 }
 
 
-void RegExpMacroAssemblerIA32::WriteStackPointerToRegister(int reg) {
+void RegExpMacroAssemblerX87::WriteStackPointerToRegister(int reg) {
   __ mov(eax, backtrack_stackpointer());
   __ sub(eax, Operand(ebp, kStackHighEnd));
   __ mov(register_location(reg), eax);
 }
 
 
 // Private methods:
 
-void RegExpMacroAssemblerIA32::CallCheckStackGuardState(Register scratch) {
+void RegExpMacroAssemblerX87::CallCheckStackGuardState(Register scratch) {
   static const int num_arguments = 3;
   __ PrepareCallCFunction(num_arguments, scratch);
   // RegExp code frame pointer.
   __ mov(Operand(esp, 2 * kPointerSize), ebp);
   // Code* of self.
   __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject()));
   // Next address on the stack (will be address of return address).
   __ lea(eax, Operand(esp, -kPointerSize));
   __ mov(Operand(esp, 0 * kPointerSize), eax);
   ExternalReference check_stack_guard =
       ExternalReference::re_check_stack_guard_state(isolate());
   __ CallCFunction(check_stack_guard, num_arguments);
 }
 
 
 // Helper function for reading a value out of a stack frame.
 template <typename T>
 static T& frame_entry(Address re_frame, int frame_offset) {
   return reinterpret_cast<T&>(Memory::int32_at(re_frame + frame_offset));
 }
 
 
-int RegExpMacroAssemblerIA32::CheckStackGuardState(Address* return_address,
+int RegExpMacroAssemblerX87::CheckStackGuardState(Address* return_address,
                                                    Code* re_code,
                                                    Address re_frame) {
   Isolate* isolate = frame_entry<Isolate*>(re_frame, kIsolate);
   if (isolate->stack_guard()->IsStackOverflow()) {
     isolate->StackOverflow();
     return EXCEPTION;
   }
 
   // If not real stack overflow the stack guard was used to interrupt
   // execution for another purpose.
@@ skipping 77 matching lines @@
     // Subject string might have been a ConsString that underwent
     // short-circuiting during GC. That will not change start_address but
     // will change pointer inside the subject handle.
     frame_entry<const String*>(re_frame, kInputString) = *subject;
   }
 
   return 0;
 }
 
 
-Operand RegExpMacroAssemblerIA32::register_location(int register_index) {
+Operand RegExpMacroAssemblerX87::register_location(int register_index) {
   ASSERT(register_index < (1<<30));
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   return Operand(ebp, kRegisterZero - register_index * kPointerSize);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckPosition(int cp_offset,
+void RegExpMacroAssemblerX87::CheckPosition(int cp_offset,
                                              Label* on_outside_input) {
   __ cmp(edi, -cp_offset * char_size());
   BranchOrBacktrack(greater_equal, on_outside_input);
 }
 
 
-void RegExpMacroAssemblerIA32::BranchOrBacktrack(Condition condition,
+void RegExpMacroAssemblerX87::BranchOrBacktrack(Condition condition,
                                                  Label* to) {
   if (condition < 0) {  // No condition
     if (to == NULL) {
       Backtrack();
       return;
     }
     __ jmp(to);
     return;
   }
   if (to == NULL) {
     __ j(condition, &backtrack_label_);
     return;
   }
   __ j(condition, to);
 }
 
 
-void RegExpMacroAssemblerIA32::SafeCall(Label* to) {
+void RegExpMacroAssemblerX87::SafeCall(Label* to) {
   Label return_to;
   __ push(Immediate::CodeRelativeOffset(&return_to));
   __ jmp(to);
   __ bind(&return_to);
 }
 
 
-void RegExpMacroAssemblerIA32::SafeReturn() {
+void RegExpMacroAssemblerX87::SafeReturn() {
   __ pop(ebx);
   __ add(ebx, Immediate(masm_->CodeObject()));
   __ jmp(ebx);
 }
 
 
-void RegExpMacroAssemblerIA32::SafeCallTarget(Label* name) {
+void RegExpMacroAssemblerX87::SafeCallTarget(Label* name) {
   __ bind(name);
 }
 
 
-void RegExpMacroAssemblerIA32::Push(Register source) {
+void RegExpMacroAssemblerX87::Push(Register source) {
   ASSERT(!source.is(backtrack_stackpointer()));
   // Notice: This updates flags, unlike normal Push.
   __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
   __ mov(Operand(backtrack_stackpointer(), 0), source);
 }
 
 
-void RegExpMacroAssemblerIA32::Push(Immediate value) {
+void RegExpMacroAssemblerX87::Push(Immediate value) {
   // Notice: This updates flags, unlike normal Push.
   __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
   __ mov(Operand(backtrack_stackpointer(), 0), value);
 }
 
 
-void RegExpMacroAssemblerIA32::Pop(Register target) {
+void RegExpMacroAssemblerX87::Pop(Register target) {
   ASSERT(!target.is(backtrack_stackpointer()));
   __ mov(target, Operand(backtrack_stackpointer(), 0));
   // Notice: This updates flags, unlike normal Pop.
   __ add(backtrack_stackpointer(), Immediate(kPointerSize));
 }
 
 
-void RegExpMacroAssemblerIA32::CheckPreemption() {
+void RegExpMacroAssemblerX87::CheckPreemption() {
   // Check for preemption.
   Label no_preempt;
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ cmp(esp, Operand::StaticVariable(stack_limit));
   __ j(above, &no_preempt);
 
   SafeCall(&check_preempt_label_);
 
   __ bind(&no_preempt);
 }
 
 
-void RegExpMacroAssemblerIA32::CheckStackLimit() {
+void RegExpMacroAssemblerX87::CheckStackLimit() {
   Label no_stack_overflow;
   ExternalReference stack_limit =
       ExternalReference::address_of_regexp_stack_limit(isolate());
   __ cmp(backtrack_stackpointer(), Operand::StaticVariable(stack_limit));
   __ j(above, &no_stack_overflow);
 
   SafeCall(&stack_overflow_label_);
 
   __ bind(&no_stack_overflow);
 }
 
 
-void RegExpMacroAssemblerIA32::LoadCurrentCharacterUnchecked(int cp_offset,
+void RegExpMacroAssemblerX87::LoadCurrentCharacterUnchecked(int cp_offset,
                                                              int characters) {
   if (mode_ == ASCII) {
     if (characters == 4) {
       __ mov(current_character(), Operand(esi, edi, times_1, cp_offset));
     } else if (characters == 2) {
       __ movzx_w(current_character(), Operand(esi, edi, times_1, cp_offset));
     } else {
       ASSERT(characters == 1);
       __ movzx_b(current_character(), Operand(esi, edi, times_1, cp_offset));
     }
@@ skipping 10 matching lines @@
   }
 }
 
 
 #undef __
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
-#endif  // V8_TARGET_ARCH_IA32
+#endif  // V8_TARGET_ARCH_X87