/*
- * Copyright (C) 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2012, 2013 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
#ifndef JITCode_h
#define JITCode_h
-#if ENABLE(JIT)
+#include "ArityCheckMode.h"
#include "CallFrame.h"
-#include "JSValue.h"
+#include "Disassembler.h"
+#include "JITStubs.h"
+#include "JSCJSValue.h"
+#include "LegacyProfiler.h"
#include "MacroAssemblerCodeRef.h"
-#include "Profiler.h"
-#endif
+#include "RegisterPreservationMode.h"
namespace JSC {
-#if ENABLE(JIT)
- class JSGlobalData;
- class RegisterFile;
-#endif
+namespace DFG {
+class CommonData;
+class JITCode;
+}
+namespace FTL {
+class ForOSREntryJITCode;
+class JITCode;
+}
+
+struct ProtoCallFrame;
+class VM;
+
+class JITCode : public ThreadSafeRefCounted<JITCode> {
+public:
+ typedef MacroAssemblerCodeRef CodeRef;
+ typedef MacroAssemblerCodePtr CodePtr;
+
+ enum JITType : uint8_t {
+ None,
+ HostCallThunk,
+ InterpreterThunk,
+ BaselineJIT,
+ DFGJIT,
+ FTLJIT
+ };
- class JITCode {
-#if ENABLE(JIT)
- typedef MacroAssemblerCodeRef CodeRef;
- typedef MacroAssemblerCodePtr CodePtr;
-#else
- JITCode() { }
-#endif
- 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);
+ static JITType bottomTierJIT()
+ {
+ return BaselineJIT;
+ }
+
+ static JITType topTierJIT()
+ {
+ return FTLJIT;
+ }
+
+ static JITType nextTierJIT(JITType jitType)
+ {
+ switch (jitType) {
+ case BaselineJIT:
return DFGJIT;
+ case DFGJIT:
+ return FTLJIT;
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ return None;
}
-
- static bool isOptimizingJIT(JITType jitType)
- {
- return jitType == DFGJIT;
+ }
+
+ static bool isExecutableScript(JITType jitType)
+ {
+ switch (jitType) {
+ case None:
+ case HostCallThunk:
+ return false;
+ default:
+ return true;
}
-
- static bool isBaselineCode(JITType jitType)
- {
- return jitType == InterpreterThunk || jitType == BaselineJIT;
+ }
+
+ static bool couldBeInterpreted(JITType jitType)
+ {
+ switch (jitType) {
+ case InterpreterThunk:
+ case BaselineJIT:
+ return true;
+ default:
+ return false;
}
-
-#if ENABLE(JIT)
- JITCode()
- : m_jitType(None)
- {
+ }
+
+ static bool isJIT(JITType jitType)
+ {
+ switch (jitType) {
+ case BaselineJIT:
+ case DFGJIT:
+ case FTLJIT:
+ return true;
+ default:
+ return false;
}
+ }
+
+ static bool isLowerTier(JITType expectedLower, JITType expectedHigher)
+ {
+ RELEASE_ASSERT(isExecutableScript(expectedLower));
+ RELEASE_ASSERT(isExecutableScript(expectedHigher));
+ return expectedLower < expectedHigher;
+ }
+
+ static bool isHigherTier(JITType expectedHigher, JITType expectedLower)
+ {
+ return isLowerTier(expectedLower, expectedHigher);
+ }
+
+ static bool isLowerOrSameTier(JITType expectedLower, JITType expectedHigher)
+ {
+ return !isHigherTier(expectedLower, expectedHigher);
+ }
+
+ static bool isHigherOrSameTier(JITType expectedHigher, JITType expectedLower)
+ {
+ return isLowerOrSameTier(expectedLower, expectedHigher);
+ }
+
+ static bool isOptimizingJIT(JITType jitType)
+ {
+ return jitType == DFGJIT || jitType == FTLJIT;
+ }
+
+ static bool isBaselineCode(JITType jitType)
+ {
+ return jitType == InterpreterThunk || jitType == BaselineJIT;
+ }
+
+protected:
+ JITCode(JITType);
+
+public:
+ virtual ~JITCode();
+
+ JITType jitType() const
+ {
+ return m_jitType;
+ }
+
+ template<typename PointerType>
+ static JITType jitTypeFor(PointerType jitCode)
+ {
+ if (!jitCode)
+ return None;
+ return jitCode->jitType();
+ }
+
+ virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) = 0;
+ virtual void* executableAddressAtOffset(size_t offset) = 0;
+ void* executableAddress() { return executableAddressAtOffset(0); }
+ virtual void* dataAddressAtOffset(size_t offset) = 0;
+ virtual unsigned offsetOf(void* pointerIntoCode) = 0;
+
+ virtual DFG::CommonData* dfgCommon();
+ virtual DFG::JITCode* dfg();
+ virtual FTL::JITCode* ftl();
+ virtual FTL::ForOSREntryJITCode* ftlForOSREntry();
+
+ JSValue execute(VM*, ProtoCallFrame*);
+
+ void* start() { return dataAddressAtOffset(0); }
+ virtual size_t size() = 0;
+ void* end() { return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(start()) + size()); }
+
+ virtual bool contains(void*) = 0;
- JITCode(const CodeRef ref, JITType jitType)
- : m_ref(ref)
- , m_jitType(jitType)
- {
- ASSERT(jitType != None);
- }
-
- bool operator !() const
- {
- return !m_ref;
- }
+private:
+ JITType m_jitType;
+};
- CodePtr addressForCall()
- {
- return m_ref.code();
- }
+class JITCodeWithCodeRef : public JITCode {
+protected:
+ JITCodeWithCodeRef(JITType);
+ JITCodeWithCodeRef(CodeRef, JITType);
- 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;
- }
+public:
+ virtual ~JITCodeWithCodeRef();
- // This function returns the offset in bytes of 'pointerIntoCode' into
- // this block of code. The pointer provided must be a pointer into this
- // 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.code().executableAddress());
- ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
- return static_cast<unsigned>(result);
- }
+ virtual void* executableAddressAtOffset(size_t offset) override;
+ virtual void* dataAddressAtOffset(size_t offset) override;
+ virtual unsigned offsetOf(void* pointerIntoCode) override;
+ virtual size_t size() override;
+ virtual bool contains(void*) override;
- // Execute the code!
- inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData)
- {
- JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), registerFile, callFrame, 0, Profiler::enabledProfilerReference(), globalData));
- return globalData->exception ? jsNull() : result;
- }
+protected:
+ CodeRef m_ref;
+};
- void* start() const
- {
- return m_ref.code().dataLocation();
- }
+class DirectJITCode : public JITCodeWithCodeRef {
+public:
+ DirectJITCode(JITType);
+ DirectJITCode(CodeRef, CodePtr withArityCheck, JITType);
+ virtual ~DirectJITCode();
+
+ void initializeCodeRef(CodeRef, CodePtr withArityCheck);
- size_t size() const
- {
- ASSERT(m_ref.code().executableAddress());
- return m_ref.size();
- }
+ virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) override;
- ExecutableMemoryHandle* getExecutableMemory()
- {
- return m_ref.executableMemory();
- }
-
- JITType jitType()
- {
- return m_jitType;
- }
+private:
+ struct RegisterPreservationWrappers {
+ CodeRef withoutArityCheck;
+ CodeRef withArityCheck;
+ };
- // 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(CodeRef code)
- {
- return JITCode(code, HostCallThunk);
- }
+ RegisterPreservationWrappers* ensureWrappers();
+
+ CodePtr m_withArityCheck;
+
+ std::unique_ptr<RegisterPreservationWrappers> m_wrappers;
+};
- void clear()
- {
- m_ref.~CodeRef();
- new (NotNull, &m_ref) CodeRef();
- }
+class NativeJITCode : public JITCodeWithCodeRef {
+public:
+ NativeJITCode(JITType);
+ NativeJITCode(CodeRef, JITType);
+ virtual ~NativeJITCode();
+
+ void initializeCodeRef(CodeRef);
- private:
- JITCode(PassRefPtr<ExecutableMemoryHandle> executableMemory, JITType jitType)
- : m_ref(executableMemory)
- , m_jitType(jitType)
- {
- }
+ virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) override;
+};
- CodeRef m_ref;
- JITType m_jitType;
-#endif // ENABLE(JIT)
- };
+} // namespace JSC
-};
+namespace WTF {
+
+class PrintStream;
+void printInternal(PrintStream&, JSC::JITCode::JITType);
+
+} // namespace WTF
#endif
projects / apple / javascriptcore.git / blobdiff