Changeset 41089 in webkit for trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h

Timestamp:

Feb 19, 2009, 2:51:40 PM (16 years ago)

Author:

[email protected]

Message:

2009-02-19 Gavin Barraclough <​[email protected]>

Reviewed by Oliver Hunt.

Fix for x86-64. Where the JavaScriptCore text segment lies outside
a 2gb range of the heap containing JIT generated code, callbacks
from JIT code to the stub functions in Interpreter will be incorrectly
linked.

No performance impact on Sunspider, 1% regression on v8-tests,
due to a 3% regression on richards.

• assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::Call::Call): (JSC::AbstractMacroAssembler::Jump::link): (JSC::AbstractMacroAssembler::Jump::linkTo): (JSC::AbstractMacroAssembler::CodeLocationJump::relink): (JSC::AbstractMacroAssembler::CodeLocationCall::relink): (JSC::AbstractMacroAssembler::ProcessorReturnAddress::relinkCallerToFunction): (JSC::AbstractMacroAssembler::PatchBuffer::link): (JSC::AbstractMacroAssembler::PatchBuffer::linkTailRecursive): (JSC::AbstractMacroAssembler::differenceBetween):
• assembler/MacroAssembler.h: (JSC::MacroAssembler::tailRecursiveCall): (JSC::MacroAssembler::makeTailRecursiveCall):
• assembler/MacroAssemblerX86.h: (JSC::MacroAssemblerX86::call):
• assembler/MacroAssemblerX86Common.h:
• assembler/MacroAssemblerX86_64.h: (JSC::MacroAssemblerX86_64::call): (JSC::MacroAssemblerX86_64::moveWithPatch): (JSC::MacroAssemblerX86_64::branchPtrWithPatch): (JSC::MacroAssemblerX86_64::storePtrWithPatch):
• assembler/X86Assembler.h: (JSC::X86Assembler::jmp_r): (JSC::X86Assembler::linkJump): (JSC::X86Assembler::patchJump): (JSC::X86Assembler::patchCall): (JSC::X86Assembler::linkCall): (JSC::X86Assembler::patchAddress):
• interpreter/Interpreter.cpp: (JSC::Interpreter::tryCTICachePutByID):
• jit/JIT.cpp: (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::putDoubleResultToJSNumberCellOrJSImmediate): (JSC::JIT::compileBinaryArithOp):
• jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompilePutByIdReplace):

File:

• trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h (modified) (12 diffs)

trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@ -266 +266 @@
         friend class AbstractMacroAssembler;
     public:
+        enum Flags {
+            None = 0x0,
+            Linkable = 0x1,
+            Near = 0x2,
+            LinkableNear = 0x3,
+        };
+
         Call()
-        {
-        }
-        
-        Call(JmpSrc jmp, bool isRelative)
+            : m_flags(None)
+        {
+        }
+        
+        Call(JmpSrc jmp, Flags flags)
             : m_jmp(jmp)
-#ifndef NDEBUG
-            , isRelative(isRelative)
-#endif
-        {
-#ifdef NDEBUG
-#pragma unused(isRelative)
-#endif
-        }
-        
-        void link(AbstractMacroAssembler<AssemblerType>* masm)
-        {
-            ASSERT(isRelative);
-            masm->m_assembler.link(m_jmp, masm->m_assembler.label());
-        }
-        
-        void linkTo(Label label, AbstractMacroAssembler<AssemblerType>* masm)
-        {
-            ASSERT(isRelative);
-            masm->m_assembler.link(m_jmp, label.m_label);
+            , m_flags(flags)
+        {
+        }
+
+        bool isFlagSet(Flags flag)
+        {
+            return m_flags & flag;
+        }
+
+        static Call fromTailJump(Jump jump)
+        {
+            return Call(jump.m_jmp, Linkable);
         }
 
     private:
         JmpSrc m_jmp;
-#ifndef NDEBUG
-        bool isRelative;
-#endif
+        Flags m_flags;
     };
 
@@ -310 +309 @@
         template<class AssemblerType_T>
         friend class AbstractMacroAssembler;
+        friend class Call;
     public:
         Jump()
@@ -322 +322 @@
         void link(AbstractMacroAssembler<AssemblerType>* masm)
         {
-            masm->m_assembler.link(m_jmp, masm->m_assembler.label());
+            masm->m_assembler.linkJump(m_jmp, masm->m_assembler.label());
         }
         
         void linkTo(Label label, AbstractMacroAssembler<AssemblerType>* masm)
         {
-            masm->m_assembler.link(m_jmp, label.m_label);
+            masm->m_assembler.linkJump(m_jmp, label.m_label);
         }
 
@@ -461 +461 @@
         void relink(CodeLocationLabel destination)
         {
-            AssemblerType::patchBranchOffset(reinterpret_cast<intptr_t>(this->m_location), destination.m_location);
+            AssemblerType::patchJump(reinterpret_cast<intptr_t>(this->m_location), destination.m_location);
         }
 
@@ -485 +485 @@
         void relink(FunctionSig* function)
         {
-            AssemblerType::patchBranchOffset(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(function));
+            AssemblerType::patchMacroAssemblerCall(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(function));
         }
 
@@ -502 +502 @@
     };
 
+    // CodeLocationNearCall:
+    //
+    // A point in the JIT code at which there is a call instruction with near linkage.
+    class CodeLocationNearCall : public CodeLocationCommon {
+        friend class CodeLocationCommon;
+        friend class PatchBuffer;
+    public:
+        CodeLocationNearCall()
+        {
+        }
+
+        template<typename FunctionSig>
+        void relink(FunctionSig* function)
+        {
+            AssemblerType::patchCall(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(function));
+        }
+
+        // This methods returns the value that will be set as the return address
+        // within a function that has been called from this call instruction.
+        void* calleeReturnAddressValue()
+        {
+            return this->m_location;
+        }
+
+    private:
+        explicit CodeLocationNearCall(void* location)
+            : CodeLocationCommon(location)
+        {
+        }
+    };
+
     // CodeLocationDataLabel32:
     //
@@ -561 +592 @@
         void relinkCallerToFunction(FunctionSig* newCalleeFunction)
         {
-            AssemblerType::patchBranchOffset(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(newCalleeFunction));
+            AssemblerType::patchMacroAssemblerCall(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(newCalleeFunction));
+        }
+        
+        template<typename FunctionSig>
+        void relinkNearCallerToFunction(FunctionSig* newCalleeFunction)
+        {
+            AssemblerType::patchCall(reinterpret_cast<intptr_t>(this->m_location), reinterpret_cast<void*>(newCalleeFunction));
         }
         
@@ -616 +653 @@
         void link(Call call, FunctionSig* function)
         {
-            AssemblerType::link(m_code, call.m_jmp, reinterpret_cast<void*>(function));
+            ASSERT(call.isFlagSet(Call::Linkable));
+#if PLATFORM(X86_64)
+            if (call.isFlagSet(Call::Near)) {
+                AssemblerType::linkCall(m_code, call.m_jmp, reinterpret_cast<void*>(function));
+            } else {
+                intptr_t callLocation = reinterpret_cast<intptr_t>(AssemblerType::getRelocatedAddress(m_code, call.m_jmp));
+                AssemblerType::patchMacroAssemblerCall(callLocation, reinterpret_cast<void*>(function));
+            }
+#else
+            AssemblerType::linkCall(m_code, call.m_jmp, reinterpret_cast<void*>(function));
+#endif
         }
         
@@ -622 +669 @@
         void linkTailRecursive(Jump jump, FunctionSig* function)
         {
-            AssemblerType::link(m_code, jump.m_jmp, reinterpret_cast<void*>(function));
+            AssemblerType::linkJump(m_code, jump.m_jmp, reinterpret_cast<void*>(function));
         }
 
@@ -628 +675 @@
         void linkTailRecursive(JumpList list, FunctionSig* function)
         {
+            for (unsigned i = 0; i < list.m_jumps.size(); ++i) {
+                AssemblerType::linkJump(m_code, list.m_jumps[i].m_jmp, reinterpret_cast<void*>(function));
+            }
+        }
+
+        void link(Jump jump, CodeLocationLabel label)
+        {
+            AssemblerType::linkJump(m_code, jump.m_jmp, label.m_location);
+        }
+
+        void link(JumpList list, CodeLocationLabel label)
+        {
             for (unsigned i = 0; i < list.m_jumps.size(); ++i)
-                AssemblerType::link(m_code, list.m_jumps[i].m_jmp, reinterpret_cast<void*>(function));
-        }
-
-        void link(Jump jump, CodeLocationLabel label)
-        {
-            AssemblerType::link(m_code, jump.m_jmp, label.m_location);
-        }
-
-        void link(JumpList list, CodeLocationLabel label)
-        {
-            for (unsigned i = 0; i < list.m_jumps.size(); ++i)
-                AssemblerType::link(m_code, list.m_jumps[i].m_jmp, label.m_location);
+                AssemblerType::linkJump(m_code, list.m_jumps[i].m_jmp, label.m_location);
         }
 
@@ -652 +700 @@
         CodeLocationCall locationOf(Call call)
         {
-            ASSERT(call.isRelative);
+            ASSERT(call.isFlagSet(Call::Linkable));
+            ASSERT(!call.isFlagSet(Call::Near));
             return CodeLocationCall(AssemblerType::getRelocatedAddress(m_code, call.m_jmp));
+        }
+
+        CodeLocationNearCall locationOfNearCall(Call call)
+        {
+            ASSERT(call.isFlagSet(Call::Linkable));
+            ASSERT(call.isFlagSet(Call::Near));
+            return CodeLocationNearCall(AssemblerType::getRelocatedAddress(m_code, call.m_jmp));
         }
 
@@ -732 +788 @@
 
     ptrdiff_t differenceBetween(DataLabelPtr from, Jump to)
+    {
+        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
+    }
+
+    ptrdiff_t differenceBetween(DataLabelPtr from, Call to)
     {
         return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);