JavaScriptCore-1097.3.3.tar.gz

[apple/javascriptcore.git] / assembler / LinkBuffer.h

diff --git a/assembler/LinkBuffer.h b/assembler/LinkBuffer.h
index ae58946d97f13a705cecef26db337d6d14c07ba9..eff320d5748bdfb5ddbaf6e93aa71bcbadc03567 100644 (file)
--- a/assembler/LinkBuffer.h
+++ b/assembler/LinkBuffer.h
@@ -28,11 +28,21 @@
 
 #if ENABLE(ASSEMBLER)
 
 
 #if ENABLE(ASSEMBLER)
 

-#include <MacroAssembler.h>
+#define DUMP_LINK_STATISTICS 0
+#define DUMP_CODE 0
+
+#define GLOBAL_THUNK_ID reinterpret_cast<void*>(static_cast<intptr_t>(-1))
+#define REGEXP_CODE_ID reinterpret_cast<void*>(static_cast<intptr_t>(-2))
+
+#include "JITCompilationEffort.h"
+#include "MacroAssembler.h"
+#include <wtf/DataLog.h>

 #include <wtf/Noncopyable.h>
 
 namespace JSC {
 
 #include <wtf/Noncopyable.h>
 
 namespace JSC {
 

+class JSGlobalData;
+

 // LinkBuffer:
 //
 // This class assists in linking code generated by the macro assembler, once code generation
 // LinkBuffer:
 //
 // This class assists in linking code generated by the macro assembler, once code generation


@@ -47,55 +57,67 @@ namespace JSC {
 //   * The address of a Label pointing into the code may be resolved.
 //   * The value referenced by a DataLabel may be set.
 //
 //   * The address of a Label pointing into the code may be resolved.
 //   * The value referenced by a DataLabel may be set.
 //

-class LinkBuffer : public Noncopyable {
+class LinkBuffer {
+    WTF_MAKE_NONCOPYABLE(LinkBuffer);

     typedef MacroAssemblerCodeRef CodeRef;
     typedef MacroAssemblerCodePtr CodePtr;
     typedef MacroAssembler::Label Label;
     typedef MacroAssembler::Jump Jump;
     typedef MacroAssemblerCodeRef CodeRef;
     typedef MacroAssemblerCodePtr CodePtr;
     typedef MacroAssembler::Label Label;
     typedef MacroAssembler::Jump Jump;

+    typedef MacroAssembler::PatchableJump PatchableJump;

     typedef MacroAssembler::JumpList JumpList;
     typedef MacroAssembler::Call Call;
     typedef MacroAssembler::JumpList JumpList;
     typedef MacroAssembler::Call Call;

+    typedef MacroAssembler::DataLabelCompact DataLabelCompact;

     typedef MacroAssembler::DataLabel32 DataLabel32;
     typedef MacroAssembler::DataLabelPtr DataLabelPtr;
     typedef MacroAssembler::DataLabel32 DataLabel32;
     typedef MacroAssembler::DataLabelPtr DataLabelPtr;

-    typedef MacroAssembler::JmpDst JmpDst;

 #if ENABLE(BRANCH_COMPACTION)
     typedef MacroAssembler::LinkRecord LinkRecord;
     typedef MacroAssembler::JumpLinkType JumpLinkType;
 #endif
 
 public:
 #if ENABLE(BRANCH_COMPACTION)
     typedef MacroAssembler::LinkRecord LinkRecord;
     typedef MacroAssembler::JumpLinkType JumpLinkType;
 #endif
 
 public:

-    // Note: Initialization sequence is significant, since executablePool is a PassRefPtr.
-    //       First, executablePool is copied into m_executablePool, then the initialization of
-    //       m_code uses m_executablePool, *not* executablePool, since this is no longer valid.
-    // The linkOffset parameter should only be non-null when recompiling for exception info
-    LinkBuffer(MacroAssembler* masm, PassRefPtr<ExecutablePool> executablePool, void* linkOffset)
-        : m_executablePool(executablePool)
-        , m_size(0)
+    LinkBuffer(JSGlobalData& globalData, MacroAssembler* masm, void* ownerUID, JITCompilationEffort effort = JITCompilationMustSucceed)
+        : m_size(0)
+#if ENABLE(BRANCH_COMPACTION)
+        , m_initialSize(0)
+#endif

         , m_code(0)
         , m_assembler(masm)
         , m_code(0)
         , m_assembler(masm)

+        , m_globalData(&globalData)

 #ifndef NDEBUG
         , m_completed(false)
 #ifndef NDEBUG
         , m_completed(false)

+        , m_effort(effort)

 #endif
     {
 #endif
     {

-        linkCode(linkOffset);
+        linkCode(ownerUID, effort);

     }
 
     ~LinkBuffer()
     {
     }
 
     ~LinkBuffer()
     {

-        ASSERT(m_completed);
+        ASSERT(m_completed || (!m_executableMemory && m_effort == JITCompilationCanFail));
+    }
+    
+    bool didFailToAllocate() const
+    {
+        return !m_executableMemory;

     }
 
     }
 

+    bool isValid() const
+    {
+        return !didFailToAllocate();
+    }
+    

     // These methods are used to link or set values at code generation time.
 
     void link(Call call, FunctionPtr function)
     {
         ASSERT(call.isFlagSet(Call::Linkable));
     // These methods are used to link or set values at code generation time.
 
     void link(Call call, FunctionPtr function)
     {
         ASSERT(call.isFlagSet(Call::Linkable));

-        call.m_jmp = applyOffset(call.m_jmp);
+        call.m_label = applyOffset(call.m_label);

         MacroAssembler::linkCall(code(), call, function);
     }
     
     void link(Jump jump, CodeLocationLabel label)
     {
         MacroAssembler::linkCall(code(), call, function);
     }
     
     void link(Jump jump, CodeLocationLabel label)
     {

-        jump.m_jmp = applyOffset(jump.m_jmp);
+        jump.m_label = applyOffset(jump.m_label);

         MacroAssembler::linkJump(code(), jump, label);
     }
 
         MacroAssembler::linkJump(code(), jump, label);
     }
 


@@ -107,13 +129,13 @@ public:
 
     void patch(DataLabelPtr label, void* value)
     {
 
     void patch(DataLabelPtr label, void* value)
     {

-        JmpDst target = applyOffset(label.m_label);
+        AssemblerLabel target = applyOffset(label.m_label);

         MacroAssembler::linkPointer(code(), target, value);
     }
 
     void patch(DataLabelPtr label, CodeLocationLabel value)
     {
         MacroAssembler::linkPointer(code(), target, value);
     }
 
     void patch(DataLabelPtr label, CodeLocationLabel value)
     {

-        JmpDst target = applyOffset(label.m_label);
+        AssemblerLabel target = applyOffset(label.m_label);

         MacroAssembler::linkPointer(code(), target, value.executableAddress());
     }
 
         MacroAssembler::linkPointer(code(), target, value.executableAddress());
     }
 


@@ -123,14 +145,19 @@ public:
     {
         ASSERT(call.isFlagSet(Call::Linkable));
         ASSERT(!call.isFlagSet(Call::Near));
     {
         ASSERT(call.isFlagSet(Call::Linkable));
         ASSERT(!call.isFlagSet(Call::Near));

-        return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp)));
+        return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));

     }
 
     CodeLocationNearCall locationOfNearCall(Call call)
     {
         ASSERT(call.isFlagSet(Call::Linkable));
         ASSERT(call.isFlagSet(Call::Near));
     }
 
     CodeLocationNearCall locationOfNearCall(Call call)
     {
         ASSERT(call.isFlagSet(Call::Linkable));
         ASSERT(call.isFlagSet(Call::Near));

-        return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp)));
+        return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
+    }
+
+    CodeLocationLabel locationOf(PatchableJump jump)
+    {
+        return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(jump.m_jump.m_label)));

     }
 
     CodeLocationLabel locationOf(Label label)
     }
 
     CodeLocationLabel locationOf(Label label)


@@ -147,31 +174,31 @@ public:
     {
         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
     }
     {
         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
     }

+    
+    CodeLocationDataLabelCompact locationOf(DataLabelCompact label)
+    {
+        return CodeLocationDataLabelCompact(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
+    }

 
     // This method obtains the return address of the call, given as an offset from
     // the start of the code.
     unsigned returnAddressOffset(Call call)
     {
 
     // This method obtains the return address of the call, given as an offset from
     // the start of the code.
     unsigned returnAddressOffset(Call call)
     {

-        call.m_jmp = applyOffset(call.m_jmp);
+        call.m_label = applyOffset(call.m_label);

         return MacroAssembler::getLinkerCallReturnOffset(call);
     }
 
         return MacroAssembler::getLinkerCallReturnOffset(call);
     }
 

-    // Upon completion of all patching either 'finalizeCode()' or 'finalizeCodeAddendum()' should be called
-    // once to complete generation of the code.  'finalizeCode()' is suited to situations
-    // where the executable pool must also be retained, the lighter-weight 'finalizeCodeAddendum()' is
-    // suited to adding to an existing allocation.
-    CodeRef finalizeCode()
+    uint32_t offsetOf(Label label)

     {
     {

-        performFinalization();
-
-        return CodeRef(m_code, m_executablePool, m_size);
+        return applyOffset(label.m_label).m_offset;

     }
 
     }
 

-    CodeLocationLabel finalizeCodeAddendum()
+    // Upon completion of all patching 'finalizeCode()' should be called once to complete generation of the code.
+    CodeRef finalizeCode()

     {
         performFinalization();
 
     {
         performFinalization();
 

-        return CodeLocationLabel(code());
+        return CodeRef(m_executableMemory);

     }
 
     CodePtr trampolineAt(Label label)
     }
 
     CodePtr trampolineAt(Label label)


@@ -179,6 +206,16 @@ public:
         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
     }
 
         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
     }
 

+    void* debugAddress()
+    {
+        return m_code;
+    }
+    
+    size_t debugSize()
+    {
+        return m_size;
+    }
+

 private:
     template <typename T> T applyOffset(T src)
     {
 private:
     template <typename T> T applyOffset(T src)
     {


@@ -188,29 +225,32 @@ private:
         return src;
     }
     
         return src;
     }
     

-    // Keep this private! - the underlying code should only be obtained externally via 
-    // finalizeCode() or finalizeCodeAddendum().
+    // Keep this private! - the underlying code should only be obtained externally via finalizeCode().

     void* code()
     {
         return m_code;
     }
 
     void* code()
     {
         return m_code;
     }
 

-    void linkCode(void* linkOffset)
+    void linkCode(void* ownerUID, JITCompilationEffort effort)

     {
     {

-        UNUSED_PARAM(linkOffset);

         ASSERT(!m_code);
 #if !ENABLE(BRANCH_COMPACTION)
         ASSERT(!m_code);
 #if !ENABLE(BRANCH_COMPACTION)

-        m_code = m_assembler->m_assembler.executableCopy(m_executablePool.get());
-        m_size = m_assembler->size();
+        m_executableMemory = m_assembler->m_assembler.executableCopy(*m_globalData, ownerUID, effort);
+        if (!m_executableMemory)
+            return;
+        m_code = m_executableMemory->start();
+        m_size = m_assembler->m_assembler.codeSize();
+        ASSERT(m_code);

 #else
 #else

-        size_t initialSize = m_assembler->size();
-        m_code = (uint8_t*)m_executablePool->alloc(initialSize);
-        if (!m_code)
+        m_initialSize = m_assembler->m_assembler.codeSize();
+        m_executableMemory = m_globalData->executableAllocator.allocate(*m_globalData, m_initialSize, ownerUID, effort);
+        if (!m_executableMemory)

             return;
             return;

-        ExecutableAllocator::makeWritable(m_code, m_assembler->size());
+        m_code = (uint8_t*)m_executableMemory->start();
+        ASSERT(m_code);
+        ExecutableAllocator::makeWritable(m_code, m_initialSize);

         uint8_t* inData = (uint8_t*)m_assembler->unlinkedCode();
         uint8_t* outData = reinterpret_cast<uint8_t*>(m_code);
         uint8_t* inData = (uint8_t*)m_assembler->unlinkedCode();
         uint8_t* outData = reinterpret_cast<uint8_t*>(m_code);

-        const uint8_t* linkBase = linkOffset ? reinterpret_cast<uint8_t*>(linkOffset) : outData;

         int readPtr = 0;
         int writePtr = 0;
         Vector<LinkRecord>& jumpsToLink = m_assembler->jumpsToLink();
         int readPtr = 0;
         int writePtr = 0;
         Vector<LinkRecord>& jumpsToLink = m_assembler->jumpsToLink();


@@ -221,7 +261,14 @@ private:
             
             // Copy the instructions from the last jump to the current one.
             size_t regionSize = jumpsToLink[i].from() - readPtr;
             
             // Copy the instructions from the last jump to the current one.
             size_t regionSize = jumpsToLink[i].from() - readPtr;

-            memcpy(outData + writePtr, inData + readPtr, regionSize);
+            uint16_t* copySource = reinterpret_cast_ptr<uint16_t*>(inData + readPtr);
+            uint16_t* copyEnd = reinterpret_cast_ptr<uint16_t*>(inData + readPtr + regionSize);
+            uint16_t* copyDst = reinterpret_cast_ptr<uint16_t*>(outData + writePtr);
+            ASSERT(!(regionSize % 2));
+            ASSERT(!(readPtr % 2));
+            ASSERT(!(writePtr % 2));
+            while (copySource != copyEnd)
+                *copyDst++ = *copySource++;

             m_assembler->recordLinkOffsets(readPtr, jumpsToLink[i].from(), offset);
             readPtr += regionSize;
             writePtr += regionSize;
             m_assembler->recordLinkOffsets(readPtr, jumpsToLink[i].from(), offset);
             readPtr += regionSize;
             writePtr += regionSize;


@@ -230,11 +277,11 @@ private:
             // branches we need to be precise, forward branches we are pessimistic
             const uint8_t* target;
             if (jumpsToLink[i].to() >= jumpsToLink[i].from())
             // branches we need to be precise, forward branches we are pessimistic
             const uint8_t* target;
             if (jumpsToLink[i].to() >= jumpsToLink[i].from())

-                target = linkBase + jumpsToLink[i].to() - offset; // Compensate for what we have collapsed so far
+                target = outData + jumpsToLink[i].to() - offset; // Compensate for what we have collapsed so far

             else
             else

-                target = linkBase + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
+                target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());

             
             

-            JumpLinkType jumpLinkType = m_assembler->computeJumpType(jumpsToLink[i], linkBase + writePtr, target);
+            JumpLinkType jumpLinkType = m_assembler->computeJumpType(jumpsToLink[i], outData + writePtr, target);

             // Compact branch if we can...
             if (m_assembler->canCompact(jumpsToLink[i].type())) {
                 // Step back in the write stream
             // Compact branch if we can...
             if (m_assembler->canCompact(jumpsToLink[i].type())) {
                 // Step back in the write stream


@@ -247,22 +294,25 @@ private:
             jumpsToLink[i].setFrom(writePtr);
         }
         // Copy everything after the last jump
             jumpsToLink[i].setFrom(writePtr);
         }
         // Copy everything after the last jump

-        memcpy(outData + writePtr, inData + readPtr, m_assembler->size() - readPtr);
-        m_assembler->recordLinkOffsets(readPtr, m_assembler->size(), readPtr - writePtr);
+        memcpy(outData + writePtr, inData + readPtr, m_initialSize - readPtr);
+        m_assembler->recordLinkOffsets(readPtr, m_initialSize, readPtr - writePtr);

         
         

-        // Actually link everything (don't link if we've be given a linkoffset as it's a
-        // waste of time: linkOffset is used for recompiling to get exception info)
-        if (!linkOffset) {
-            for (unsigned i = 0; i < jumpCount; ++i) {
-                uint8_t* location = outData + jumpsToLink[i].from();
-                uint8_t* target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
-                m_assembler->link(jumpsToLink[i], location, target);
-            }
+        for (unsigned i = 0; i < jumpCount; ++i) {
+            uint8_t* location = outData + jumpsToLink[i].from();
+            uint8_t* target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
+            m_assembler->link(jumpsToLink[i], location, target);

         }
 
         jumpsToLink.clear();
         }
 
         jumpsToLink.clear();

-        m_size = writePtr + m_assembler->size() - readPtr;
-        m_executablePool->tryShrink(m_code, initialSize, m_size);
+        m_size = writePtr + m_initialSize - readPtr;
+        m_executableMemory->shrink(m_size);
+
+#if DUMP_LINK_STATISTICS
+        dumpLinkStatistics(m_code, m_initialSize, m_size);
+#endif
+#if DUMP_CODE
+        dumpCode(m_code, m_size);
+#endif

 #endif
     }
 
 #endif
     }
 


@@ -270,19 +320,93 @@ private:
     {
 #ifndef NDEBUG
         ASSERT(!m_completed);
     {
 #ifndef NDEBUG
         ASSERT(!m_completed);

+        ASSERT(isValid());

         m_completed = true;
 #endif
 
         m_completed = true;
 #endif
 

+#if ENABLE(BRANCH_COMPACTION)
+        ExecutableAllocator::makeExecutable(code(), m_initialSize);
+#else

         ExecutableAllocator::makeExecutable(code(), m_size);
         ExecutableAllocator::makeExecutable(code(), m_size);

-        ExecutableAllocator::cacheFlush(code(), m_size);
+#endif
+        MacroAssembler::cacheFlush(code(), m_size);

     }
 
     }
 

-    RefPtr<ExecutablePool> m_executablePool;
+#if DUMP_LINK_STATISTICS
+    static void dumpLinkStatistics(void* code, size_t initialSize, size_t finalSize)
+    {
+        static unsigned linkCount = 0;
+        static unsigned totalInitialSize = 0;
+        static unsigned totalFinalSize = 0;
+        linkCount++;
+        totalInitialSize += initialSize;
+        totalFinalSize += finalSize;
+        dataLog("link %p: orig %u, compact %u (delta %u, %.2f%%)\n", 
+                    code, static_cast<unsigned>(initialSize), static_cast<unsigned>(finalSize),
+                    static_cast<unsigned>(initialSize - finalSize),
+                    100.0 * (initialSize - finalSize) / initialSize);
+        dataLog("\ttotal %u: orig %u, compact %u (delta %u, %.2f%%)\n", 
+                    linkCount, totalInitialSize, totalFinalSize, totalInitialSize - totalFinalSize,
+                    100.0 * (totalInitialSize - totalFinalSize) / totalInitialSize);
+    }
+#endif
+    
+#if DUMP_CODE
+    static void dumpCode(void* code, size_t size)
+    {
+#if CPU(ARM_THUMB2)
+        // Dump the generated code in an asm file format that can be assembled and then disassembled
+        // for debugging purposes. For example, save this output as jit.s:
+        //   gcc -arch armv7 -c jit.s
+        //   otool -tv jit.o
+        static unsigned codeCount = 0;
+        unsigned short* tcode = static_cast<unsigned short*>(code);
+        size_t tsize = size / sizeof(short);
+        char nameBuf[128];
+        snprintf(nameBuf, sizeof(nameBuf), "_jsc_jit%u", codeCount++);
+        dataLog("\t.syntax unified\n"
+                    "\t.section\t__TEXT,__text,regular,pure_instructions\n"
+                    "\t.globl\t%s\n"
+                    "\t.align 2\n"
+                    "\t.code 16\n"
+                    "\t.thumb_func\t%s\n"
+                    "# %p\n"
+                    "%s:\n", nameBuf, nameBuf, code, nameBuf);
+        
+        for (unsigned i = 0; i < tsize; i++)
+            dataLog("\t.short\t0x%x\n", tcode[i]);
+#elif CPU(ARM_TRADITIONAL)
+        //   gcc -c jit.s
+        //   objdump -D jit.o
+        static unsigned codeCount = 0;
+        unsigned int* tcode = static_cast<unsigned int*>(code);
+        size_t tsize = size / sizeof(unsigned int);
+        char nameBuf[128];
+        snprintf(nameBuf, sizeof(nameBuf), "_jsc_jit%u", codeCount++);
+        dataLog("\t.globl\t%s\n"
+                    "\t.align 4\n"
+                    "\t.code 32\n"
+                    "\t.text\n"
+                    "# %p\n"
+                    "%s:\n", nameBuf, code, nameBuf);
+
+        for (unsigned i = 0; i < tsize; i++)
+            dataLog("\t.long\t0x%x\n", tcode[i]);
+#endif
+    }
+#endif
+    
+    RefPtr<ExecutableMemoryHandle> m_executableMemory;

     size_t m_size;
     size_t m_size;

+#if ENABLE(BRANCH_COMPACTION)
+    size_t m_initialSize;
+#endif

     void* m_code;
     MacroAssembler* m_assembler;
     void* m_code;
     MacroAssembler* m_assembler;

+    JSGlobalData* m_globalData;

 #ifndef NDEBUG
     bool m_completed;
 #ifndef NDEBUG
     bool m_completed;

+    JITCompilationEffort m_effort;

 #endif
 };
 
 #endif
 };