JavaScriptCore-1097.3.tar.gz

[apple/javascriptcore.git] / jit / SpecializedThunkJIT.h

diff --git a/jit/SpecializedThunkJIT.h b/jit/SpecializedThunkJIT.h
index 13a5c2eee6e9afe31e8896571b492c01dbb76062..74e94ea3c70ca767fb2e45b3b58d96c50e04aa1f 100644 (file)
--- a/jit/SpecializedThunkJIT.h
+++ b/jit/SpecializedThunkJIT.h
@@ -37,37 +37,35 @@ namespace JSC {
     class SpecializedThunkJIT : public JSInterfaceJIT {
     public:
         static const int ThisArgument = -1;
-        SpecializedThunkJIT(int expectedArgCount, JSGlobalData* globalData, ExecutablePool* pool)
+        SpecializedThunkJIT(int expectedArgCount, JSGlobalData* globalData)
             : m_expectedArgCount(expectedArgCount)
             , m_globalData(globalData)
-            , m_pool(pool)
         {
             // Check that we have the expected number of arguments
-            m_failures.append(branch32(NotEqual, Address(callFrameRegister, RegisterFile::ArgumentCount * (int)sizeof(Register)), TrustedImm32(expectedArgCount + 1)));
+            m_failures.append(branch32(NotEqual, payloadFor(RegisterFile::ArgumentCount), TrustedImm32(expectedArgCount + 1)));
         }
         
         void loadDoubleArgument(int argument, FPRegisterID dst, RegisterID scratch)
         {
-            unsigned src = argumentToVirtualRegister(argument);
+            unsigned src = CallFrame::argumentOffset(argument);
             m_failures.append(emitLoadDouble(src, dst, scratch));
         }
         
         void loadCellArgument(int argument, RegisterID dst)
         {
-            unsigned src = argumentToVirtualRegister(argument);
+            unsigned src = CallFrame::argumentOffset(argument);
             m_failures.append(emitLoadJSCell(src, dst));
         }
         
         void loadJSStringArgument(int argument, RegisterID dst)
         {
             loadCellArgument(argument, dst);
-            m_failures.append(branchPtr(NotEqual, Address(dst, 0), TrustedImmPtr(m_globalData->jsStringVPtr)));
-            m_failures.append(branchTest32(NonZero, Address(dst, OBJECT_OFFSETOF(JSString, m_fiberCount))));
+            m_failures.append(branchPtr(NotEqual, Address(dst, JSCell::classInfoOffset()), TrustedImmPtr(&JSString::s_info)));
         }
         
         void loadInt32Argument(int argument, RegisterID dst, Jump& failTarget)
         {
-            unsigned src = argumentToVirtualRegister(argument);
+            unsigned src = CallFrame::argumentOffset(argument);
             failTarget = emitLoadInt32(src, dst);
         }
         
@@ -95,11 +93,22 @@ namespace JSC {
         {
 #if USE(JSVALUE64)
             moveDoubleToPtr(src, regT0);
+            Jump zero = branchTestPtr(Zero, regT0);
             subPtr(tagTypeNumberRegister, regT0);
+            Jump done = jump();
+            zero.link(this);
+            move(tagTypeNumberRegister, regT0);
+            done.link(this);
 #else
             storeDouble(src, Address(stackPointerRegister, -(int)sizeof(double)));
             loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(JSValue, u.asBits.tag) - sizeof(double)), regT1);
             loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(JSValue, u.asBits.payload) - sizeof(double)), regT0);
+            Jump lowNonZero = branchTestPtr(NonZero, regT1);
+            Jump highNonZero = branchTestPtr(NonZero, regT0);
+            move(TrustedImm32(0), regT0);
+            move(TrustedImm32(Int32Tag), regT1);
+            lowNonZero.link(this);
+            highNonZero.link(this);
 #endif
             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
             ret();
@@ -123,19 +132,24 @@ namespace JSC {
             ret();
         }
         
-        MacroAssemblerCodePtr finalize(JSGlobalData& globalData, MacroAssemblerCodePtr fallback)
+        MacroAssemblerCodeRef finalize(JSGlobalData& globalData, MacroAssemblerCodePtr fallback)
         {
-            LinkBuffer patchBuffer(globalData, this, m_pool.get());
+            LinkBuffer patchBuffer(globalData, this, GLOBAL_THUNK_ID);
             patchBuffer.link(m_failures, CodeLocationLabel(fallback));
-            return patchBuffer.finalizeCode().m_code;
+            for (unsigned i = 0; i < m_calls.size(); i++)
+                patchBuffer.link(m_calls[i].first, m_calls[i].second);
+            return patchBuffer.finalizeCode();
         }
-        
-    private:
-        int argumentToVirtualRegister(unsigned argument)
+
+        // Assumes that the target function uses fpRegister0 as the first argument
+        // and return value. Like any sensible architecture would.
+        void callDoubleToDouble(FunctionPtr function)
         {
-            return -static_cast<int>(RegisterFile::CallFrameHeaderSize + (m_expectedArgCount - argument));
+            m_calls.append(std::make_pair(call(), function));
         }
 
+    private:
+
         void tagReturnAsInt32()
         {
 #if USE(JSVALUE64)
@@ -154,8 +168,8 @@ namespace JSC {
         
         int m_expectedArgCount;
         JSGlobalData* m_globalData;
-        RefPtr<ExecutablePool> m_pool;
         MacroAssembler::JumpList m_failures;
+        Vector<std::pair<Call, FunctionPtr> > m_calls;
     };
 
 }