CodeBlock refactoring broke profile dumping
[WebKit-https.git] / Source / JavaScriptCore / jit / JITCode.h
1 /*
2  * Copyright (C) 2008, 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef JITCode_h
27 #define JITCode_h
28
29 #if ENABLE(JIT) || ENABLE(LLINT)
30 #include "CallFrame.h"
31 #include "Disassembler.h"
32 #include "JITStubs.h"
33 #include "JSCJSValue.h"
34 #include "LegacyProfiler.h"
35 #include "MacroAssemblerCodeRef.h"
36 #endif
37
38 namespace JSC {
39
40 namespace DFG {
41 class CommonData;
42 class JITCode;
43 }
44 namespace FTL {
45 class JITCode;
46 }
47
48 #if ENABLE(JIT)
49 class VM;
50 class JSStack;
51 #endif
52
53 class JITCode : public ThreadSafeRefCounted<JITCode> {
54 public:
55     typedef MacroAssemblerCodeRef CodeRef;
56     typedef MacroAssemblerCodePtr CodePtr;
57
58     enum JITType { None, HostCallThunk, InterpreterThunk, BaselineJIT, DFGJIT, FTLJIT };
59     
60     static JITType bottomTierJIT()
61     {
62         return BaselineJIT;
63     }
64     
65     static JITType topTierJIT()
66     {
67         return FTLJIT;
68     }
69     
70     static JITType nextTierJIT(JITType jitType)
71     {
72         switch (jitType) {
73         case BaselineJIT:
74             return DFGJIT;
75         case DFGJIT:
76             return FTLJIT;
77         default:
78             RELEASE_ASSERT_NOT_REACHED();
79             return None;
80         }
81     }
82     
83     static bool isExecutableScript(JITType jitType)
84     {
85         switch (jitType) {
86         case None:
87         case HostCallThunk:
88             return false;
89         default:
90             return true;
91         }
92     }
93     
94     static bool couldBeInterpreted(JITType jitType)
95     {
96         switch (jitType) {
97         case InterpreterThunk:
98         case BaselineJIT:
99             return true;
100         default:
101             return false;
102         }
103     }
104     
105     static bool isJIT(JITType jitType)
106     {
107         switch (jitType) {
108         case BaselineJIT:
109         case DFGJIT:
110         case FTLJIT:
111             return true;
112         default:
113             return false;
114         }
115     }
116     
117     static bool isLowerTier(JITType expectedLower, JITType expectedHigher)
118     {
119         RELEASE_ASSERT(isExecutableScript(expectedLower));
120         RELEASE_ASSERT(isExecutableScript(expectedHigher));
121         return expectedLower < expectedHigher;
122     }
123     
124     static bool isHigherTier(JITType expectedHigher, JITType expectedLower)
125     {
126         return isLowerTier(expectedLower, expectedHigher);
127     }
128     
129     static bool isLowerOrSameTier(JITType expectedLower, JITType expectedHigher)
130     {
131         return !isHigherTier(expectedLower, expectedHigher);
132     }
133     
134     static bool isHigherOrSameTier(JITType expectedHigher, JITType expectedLower)
135     {
136         return isLowerOrSameTier(expectedLower, expectedHigher);
137     }
138     
139     static bool isOptimizingJIT(JITType jitType)
140     {
141         return jitType == DFGJIT || jitType == FTLJIT;
142     }
143     
144     static bool isBaselineCode(JITType jitType)
145     {
146         return jitType == InterpreterThunk || jitType == BaselineJIT;
147     }
148     
149 protected:
150     JITCode(JITType);
151     
152 public:
153     virtual ~JITCode();
154     
155     JITType jitType() const
156     {
157         return m_jitType;
158     }
159     
160     template<typename PointerType>
161     static JITType jitTypeFor(PointerType jitCode)
162     {
163         if (!jitCode)
164             return None;
165         return jitCode->jitType();
166     }
167     
168     virtual CodePtr addressForCall() = 0;
169     virtual void* executableAddressAtOffset(size_t offset) = 0;
170     void* executableAddress() { return executableAddressAtOffset(0); }
171     virtual void* dataAddressAtOffset(size_t offset) = 0;
172     virtual unsigned offsetOf(void* pointerIntoCode) = 0;
173     
174     virtual DFG::CommonData* dfgCommon();
175     virtual DFG::JITCode* dfg();
176     virtual FTL::JITCode* ftl();
177     
178     JSValue execute(JSStack*, CallFrame*, VM*);
179     
180     void* start() { return dataAddressAtOffset(0); }
181     virtual size_t size() = 0;
182     void* end() { return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(start()) + size()); }
183     
184     virtual bool contains(void*) = 0;
185
186     static PassRefPtr<JITCode> hostFunction(CodeRef);
187
188 private:
189     JITType m_jitType;
190 };
191
192 class DirectJITCode : public JITCode {
193 public:
194     DirectJITCode(JITType);
195     DirectJITCode(const CodeRef, JITType);
196     ~DirectJITCode();
197     
198     void initializeCodeRef(CodeRef ref);
199
200     CodePtr addressForCall();
201     void* executableAddressAtOffset(size_t offset);
202     void* dataAddressAtOffset(size_t offset);
203     unsigned offsetOf(void* pointerIntoCode);
204     size_t size();
205     bool contains(void*);
206
207 private:
208     CodeRef m_ref;
209 };
210
211 } // namespace JSC
212
213 namespace WTF {
214
215 class PrintStream;
216 void printInternal(PrintStream&, JSC::JITCode::JITType);
217
218 } // namespace WTF
219
220 #endif