1 files changed, 56 insertions, 17 deletions

diff --git a/Source/JavaScriptCore/jit/JITCode.h b/Source/JavaScriptCore/jit/JITCode.h
index 52c78111a..7fb7b3134 100644
--- a/Source/JavaScriptCore/jit/JITCode.h
+++ b/Source/JavaScriptCore/jit/JITCode.h
@@ -26,14 +26,14 @@
 #ifndef JITCode_h
 #define JITCode_h
 
-#if ENABLE(JIT) || ENABLE(LLINT)
+#include "ArityCheckMode.h"
 #include "CallFrame.h"
+#include "CodeOrigin.h"
 #include "Disassembler.h"
-#include "JITStubs.h"
 #include "JSCJSValue.h"
-#include "LegacyProfiler.h"
 #include "MacroAssemblerCodeRef.h"
-#endif
+#include "RegisterSet.h"
+#include <wtf/Optional.h>
 
 namespace JSC {
 
@@ -47,6 +47,7 @@ class JITCode;
 }
 
 struct ProtoCallFrame;
+class TrackedReferences;
 class VM;
 
 class JITCode : public ThreadSafeRefCounted<JITCode> {
@@ -54,8 +55,17 @@ public:
     typedef MacroAssemblerCodeRef CodeRef;
     typedef MacroAssemblerCodePtr CodePtr;
 
-    enum JITType { None, HostCallThunk, InterpreterThunk, BaselineJIT, DFGJIT, FTLJIT };
+    enum JITType : uint8_t {
+        None,
+        HostCallThunk,
+        InterpreterThunk,
+        BaselineJIT,
+        DFGJIT,
+        FTLJIT
+    };
     
+    static const char* typeName(JITType);
+
     static JITType bottomTierJIT()
     {
         return BaselineJIT;
@@ -112,7 +122,7 @@ public:
             return false;
         }
     }
-    
+
     static bool isLowerTier(JITType expectedLower, JITType expectedHigher)
     {
         RELEASE_ASSERT(isExecutableScript(expectedLower));
@@ -164,7 +174,7 @@ public:
         return jitCode->jitType();
     }
     
-    virtual CodePtr addressForCall() = 0;
+    virtual CodePtr addressForCall(ArityCheckMode) = 0;
     virtual void* executableAddressAtOffset(size_t offset) = 0;
     void* executableAddress() { return executableAddressAtOffset(0); }
     virtual void* dataAddressAtOffset(size_t offset) = 0;
@@ -175,7 +185,9 @@ public:
     virtual FTL::JITCode* ftl();
     virtual FTL::ForOSREntryJITCode* ftlForOSREntry();
     
-    JSValue execute(VM*, ProtoCallFrame*, Register*);
+    virtual void validateReferences(const TrackedReferences&);
+    
+    JSValue execute(VM*, ProtoCallFrame*);
     
     void* start() { return dataAddressAtOffset(0); }
     virtual size_t size() = 0;
@@ -183,31 +195,58 @@ public:
     
     virtual bool contains(void*) = 0;
 
-    static PassRefPtr<JITCode> hostFunction(CodeRef);
+#if ENABLE(JIT)
+    virtual RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex);
+    virtual Optional<CodeOrigin> findPC(CodeBlock*, void* pc) { UNUSED_PARAM(pc); return Nullopt; }
+#endif
 
 private:
     JITType m_jitType;
 };
 
-class DirectJITCode : public JITCode {
+class JITCodeWithCodeRef : public JITCode {
+protected:
+    JITCodeWithCodeRef(JITType);
+    JITCodeWithCodeRef(CodeRef, JITType);
+
 public:
-    DirectJITCode(JITType);
-    DirectJITCode(const CodeRef, JITType);
-    virtual ~DirectJITCode();
-    
-    void initializeCodeRef(CodeRef ref);
+    virtual ~JITCodeWithCodeRef();
 
-    virtual CodePtr addressForCall() override;
     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;
 
-private:
+protected:
     CodeRef m_ref;
 };
 
+class DirectJITCode : public JITCodeWithCodeRef {
+public:
+    DirectJITCode(JITType);
+    DirectJITCode(CodeRef, CodePtr withArityCheck, JITType);
+    virtual ~DirectJITCode();
+    
+    void initializeCodeRef(CodeRef, CodePtr withArityCheck);
+
+    virtual CodePtr addressForCall(ArityCheckMode) override;
+
+private:
+    CodePtr m_withArityCheck;
+};
+
+class NativeJITCode : public JITCodeWithCodeRef {
+public:
+    NativeJITCode(JITType);
+    NativeJITCode(CodeRef, JITType);
+    virtual ~NativeJITCode();
+    
+    void initializeCodeRef(CodeRef);
+
+    virtual CodePtr addressForCall(ArityCheckMode) override;
+};
+
 } // namespace JSC
 
 namespace WTF {