JavaScriptCore-1097.13.tar.gz

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

diff --git a/jit/JITCode.h b/jit/JITCode.h
index 69cf16728e22c6104c81057f96be053b6ef485fe..3ae5ff234e9adef6be3bfc3f85d486a4d0b0d688 100644 (file)
--- a/jit/JITCode.h
+++ b/jit/JITCode.h
@@ -26,41 +26,89 @@
 #ifndef JITCode_h
 #define JITCode_h
 
 #ifndef JITCode_h
 #define JITCode_h
 

-#include <wtf/Platform.h>
-

 #if ENABLE(JIT)
 #if ENABLE(JIT)

-

 #include "CallFrame.h"
 #include "JSValue.h"
 #include "MacroAssemblerCodeRef.h"
 #include "Profiler.h"
 #include "CallFrame.h"
 #include "JSValue.h"
 #include "MacroAssemblerCodeRef.h"
 #include "Profiler.h"

+#endif

 
 namespace JSC {
 
 
 namespace JSC {
 

+#if ENABLE(JIT)

     class JSGlobalData;
     class RegisterFile;
     class JSGlobalData;
     class RegisterFile;

-
+#endif
+    

     class JITCode {
     class JITCode {

+#if ENABLE(JIT)

         typedef MacroAssemblerCodeRef CodeRef;
         typedef MacroAssemblerCodePtr CodePtr;
         typedef MacroAssemblerCodeRef CodeRef;
         typedef MacroAssemblerCodePtr CodePtr;

+#else
+        JITCode() { }
+#endif

     public:
     public:

+        enum JITType { None, HostCallThunk, InterpreterThunk, BaselineJIT, DFGJIT };
+        
+        static JITType bottomTierJIT()
+        {
+            return BaselineJIT;
+        }
+        
+        static JITType topTierJIT()
+        {
+            return DFGJIT;
+        }
+        
+        static JITType nextTierJIT(JITType jitType)
+        {
+            ASSERT_UNUSED(jitType, jitType == BaselineJIT || jitType == DFGJIT);
+            return DFGJIT;
+        }
+        
+        static bool isOptimizingJIT(JITType jitType)
+        {
+            return jitType == DFGJIT;
+        }
+        
+        static bool isBaselineCode(JITType jitType)
+        {
+            return jitType == InterpreterThunk || jitType == BaselineJIT;
+        }
+        
+#if ENABLE(JIT)

         JITCode()
         JITCode()

+            : m_jitType(None)

         {
         }
 
         {
         }
 

-        JITCode(const CodeRef ref)
+        JITCode(const CodeRef ref, JITType jitType)

             : m_ref(ref)
             : m_ref(ref)

+            , m_jitType(jitType)

         {
         {

+            ASSERT(jitType != None);

         }
         }

-
+        

         bool operator !() const
         {
         bool operator !() const
         {

-            return !m_ref.m_code.executableAddress();
+            return !m_ref;

         }
 
         CodePtr addressForCall()
         {
         }
 
         CodePtr addressForCall()
         {

-            return m_ref.m_code;
+            return m_ref.code();
+        }
+
+        void* executableAddressAtOffset(size_t offset) const
+        {
+            ASSERT(offset < size());
+            return reinterpret_cast<char*>(m_ref.code().executableAddress()) + offset;
+        }
+        
+        void* dataAddressAtOffset(size_t offset) const
+        {
+            ASSERT(offset < size());
+            return reinterpret_cast<char*>(m_ref.code().dataLocation()) + offset;

         }
 
         // This function returns the offset in bytes of 'pointerIntoCode' into
         }
 
         // This function returns the offset in bytes of 'pointerIntoCode' into


@@ -68,51 +116,64 @@ namespace JSC {
         // block of code.  It is ASSERTed that no codeblock >4gb in size.
         unsigned offsetOf(void* pointerIntoCode)
         {
         // block of code.  It is ASSERTed that no codeblock >4gb in size.
         unsigned offsetOf(void* pointerIntoCode)
         {

-            intptr_t result = reinterpret_cast<intptr_t>(pointerIntoCode) - reinterpret_cast<intptr_t>(m_ref.m_code.executableAddress());
+            intptr_t result = reinterpret_cast<intptr_t>(pointerIntoCode) - reinterpret_cast<intptr_t>(m_ref.code().executableAddress());

             ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
             return static_cast<unsigned>(result);
         }
 
         // Execute the code!
             ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
             return static_cast<unsigned>(result);
         }
 
         // Execute the code!

-        inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData, JSValue* exception)
+        inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData)

         {
         {

-            return JSValue::decode(ctiTrampoline(m_ref.m_code.executableAddress(), registerFile, callFrame, exception, Profiler::enabledProfilerReference(), globalData));
+            JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), registerFile, callFrame, 0, Profiler::enabledProfilerReference(), globalData));
+            return globalData->exception ? jsNull() : result;

         }
 
         }
 

-        void* start()
+        void* start() const

         {
         {

-            return m_ref.m_code.dataLocation();
+            return m_ref.code().dataLocation();

         }
 
         }
 

-        size_t size()
+        size_t size() const

         {
         {

-            ASSERT(m_ref.m_code.executableAddress());
-            return m_ref.m_size;
+            ASSERT(m_ref.code().executableAddress());
+            return m_ref.size();

         }
 
         }
 

-        ExecutablePool* getExecutablePool()
+        ExecutableMemoryHandle* getExecutableMemory()
+        {
+            return m_ref.executableMemory();
+        }
+        
+        JITType jitType()

         {
         {

-            return m_ref.m_executablePool.get();
+            return m_jitType;

         }
 
         // Host functions are a bit special; they have a m_code pointer but they
         // do not individully ref the executable pool containing the trampoline.
         }
 
         // Host functions are a bit special; they have a m_code pointer but they
         // do not individully ref the executable pool containing the trampoline.

-        static JITCode HostFunction(CodePtr code)
+        static JITCode HostFunction(CodeRef code)
+        {
+            return JITCode(code, HostCallThunk);
+        }
+
+        void clear()

         {
         {

-            return JITCode(code.dataLocation(), 0, 0);
+            m_ref.~CodeRef();
+            new (NotNull, &m_ref) CodeRef();

         }
 
     private:
         }
 
     private:

-        JITCode(void* code, PassRefPtr<ExecutablePool> executablePool, size_t size)
-            : m_ref(code, executablePool, size)
+        JITCode(PassRefPtr<ExecutableMemoryHandle> executableMemory, JITType jitType)
+            : m_ref(executableMemory)
+            , m_jitType(jitType)

         {
         }
 
         CodeRef m_ref;
         {
         }
 
         CodeRef m_ref;

+        JITType m_jitType;
+#endif // ENABLE(JIT)

     };
 
 };
 
 #endif
     };
 
 };
 
 #endif

-
-#endif