Introduce x87 port

src/x87/code-stubs-x87.h

 // Copyright 2011 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.
 
-#ifndef V8_IA32_CODE_STUBS_IA32_H_
-#define V8_IA32_CODE_STUBS_IA32_H_
+#ifndef V8_X87_CODE_STUBS_X87_H_
+#define V8_X87_CODE_STUBS_X87_H_
 
 #include "macro-assembler.h"
 #include "ic-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 void ArrayNativeCode(MacroAssembler* masm,
                      bool construct_call,
                      Label* call_generic_code);
 
 
 class StoreBufferOverflowStub: public PlatformCodeStub {
  public:
-  StoreBufferOverflowStub(Isolate* isolate, SaveFPRegsMode save_fp)
-      : PlatformCodeStub(isolate), save_doubles_(save_fp) { }
+  explicit StoreBufferOverflowStub(Isolate* isolate)
+      : PlatformCodeStub(isolate) { }
 
   void Generate(MacroAssembler* masm);
 
   static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
   virtual bool SometimesSetsUpAFrame() { return false; }
 
  private:
-  SaveFPRegsMode save_doubles_;
-
   Major MajorKey() { return StoreBufferOverflow; }
-  int MinorKey() { return (save_doubles_ == kSaveFPRegs) ? 1 : 0; }
+  int MinorKey() { return 0; }
 };
 
 
 class StringHelper : public AllStatic {
  public:
   // Generate code for copying characters using the rep movs instruction.
   // Copies ecx characters from esi to edi. Copying of overlapping regions is
   // not supported.
   static void GenerateCopyCharactersREP(MacroAssembler* masm,
                                         Register dest,     // Must be edi.
@@ skipping 131 matching lines @@
   LookupMode mode_;
 };
 
 
 class RecordWriteStub: public PlatformCodeStub {
  public:
   RecordWriteStub(Isolate* isolate,
                   Register object,
                   Register value,
                   Register address,
-                  RememberedSetAction remembered_set_action,
-                  SaveFPRegsMode fp_mode)
+                  RememberedSetAction remembered_set_action)
       : PlatformCodeStub(isolate),
         object_(object),
         value_(value),
         address_(address),
         remembered_set_action_(remembered_set_action),
-        save_fp_regs_mode_(fp_mode),
         regs_(object,   // An input reg.
               address,  // An input reg.
               value) {  // One scratch reg.
   }
 
   enum Mode {
     STORE_BUFFER_ONLY,
     INCREMENTAL,
     INCREMENTAL_COMPACTION
   };
@@ skipping 120 matching lines @@
           !ecx.is(address_orig_)) {
         masm->pop(ecx);
       }
       if (!scratch0_.is(scratch0_orig_)) masm->pop(scratch0_);
     }
 
     // If we have to call into C then we need to save and restore all caller-
     // saved registers that were not already preserved.  The caller saved
     // registers are eax, ecx and edx.  The three scratch registers (incl. ecx)
     // will be restored by other means so we don't bother pushing them here.
-    void SaveCallerSaveRegisters(MacroAssembler* masm, SaveFPRegsMode mode) {
+    void SaveCallerSaveRegisters(MacroAssembler* masm) {
       if (!scratch0_.is(eax) && !scratch1_.is(eax)) masm->push(eax);
       if (!scratch0_.is(edx) && !scratch1_.is(edx)) masm->push(edx);
-      if (mode == kSaveFPRegs) {
-        masm->sub(esp,
-                  Immediate(kDoubleSize * (XMMRegister::kMaxNumRegisters - 1)));
-        // Save all XMM registers except XMM0.
-        for (int i = XMMRegister::kMaxNumRegisters - 1; i > 0; i--) {
-          XMMRegister reg = XMMRegister::from_code(i);
-          masm->movsd(Operand(esp, (i - 1) * kDoubleSize), reg);
-        }
-      }
     }
 
-    inline void RestoreCallerSaveRegisters(MacroAssembler*masm,
-                                           SaveFPRegsMode mode) {
-      if (mode == kSaveFPRegs) {
-        // Restore all XMM registers except XMM0.
-        for (int i = XMMRegister::kMaxNumRegisters - 1; i > 0; i--) {
-          XMMRegister reg = XMMRegister::from_code(i);
-          masm->movsd(reg, Operand(esp, (i - 1) * kDoubleSize));
-        }
-        masm->add(esp,
-                  Immediate(kDoubleSize * (XMMRegister::kMaxNumRegisters - 1)));
-      }
+    inline void RestoreCallerSaveRegisters(MacroAssembler*masm) {
       if (!scratch0_.is(edx) && !scratch1_.is(edx)) masm->pop(edx);
       if (!scratch0_.is(eax) && !scratch1_.is(eax)) masm->pop(eax);
     }
 
     inline Register object() { return object_; }
     inline Register address() { return address_; }
     inline Register scratch0() { return scratch0_; }
     inline Register scratch1() { return scratch1_; }
 
    private:
@@ skipping 35 matching lines @@
       OnNoNeedToInformIncrementalMarker on_no_need,
       Mode mode);
   void InformIncrementalMarker(MacroAssembler* masm);
 
   Major MajorKey() { return RecordWrite; }
 
   int MinorKey() {
     return ObjectBits::encode(object_.code()) |
         ValueBits::encode(value_.code()) |
         AddressBits::encode(address_.code()) |
-        RememberedSetActionBits::encode(remembered_set_action_) |
-        SaveFPRegsModeBits::encode(save_fp_regs_mode_);
+        RememberedSetActionBits::encode(remembered_set_action_);
   }
 
   void Activate(Code* code) {
     code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
   }
 
   class ObjectBits: public BitField<int, 0, 3> {};
   class ValueBits: public BitField<int, 3, 3> {};
   class AddressBits: public BitField<int, 6, 3> {};
   class RememberedSetActionBits: public BitField<RememberedSetAction, 9, 1> {};
-  class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 10, 1> {};
 
   Register object_;
   Register value_;
   Register address_;
   RememberedSetAction remembered_set_action_;
-  SaveFPRegsMode save_fp_regs_mode_;
   RegisterAllocation regs_;
 };
 
 
 } }  // namespace v8::internal
 
-#endif  // V8_IA32_CODE_STUBS_IA32_H_
+#endif  // V8_X87_CODE_STUBS_X87_H_