One file per class for Executable.h/.cpp
[WebKit-https.git] / Source / JavaScriptCore / runtime / ScriptExecutable.h
1 /*
2  * Copyright (C) 2009, 2010, 2013-2016 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 #pragma once
27
28 #include "ExecutableBase.h"
29
30 namespace JSC {
31
32 class ScriptExecutable : public ExecutableBase {
33 public:
34     typedef ExecutableBase Base;
35     static const unsigned StructureFlags = Base::StructureFlags;
36
37     static void destroy(JSCell*);
38         
39     CodeBlockHash hashFor(CodeSpecializationKind) const;
40
41     const SourceCode& source() const { return m_source; }
42     intptr_t sourceID() const { return m_source.providerID(); }
43     const String& sourceURL() const { return m_source.provider()->url(); }
44     int firstLine() const { return m_firstLine; }
45     void setOverrideLineNumber(int overrideLineNumber) { m_overrideLineNumber = overrideLineNumber; }
46     bool hasOverrideLineNumber() const { return m_overrideLineNumber != -1; }
47     int overrideLineNumber() const { return m_overrideLineNumber; }
48     int lastLine() const { return m_lastLine; }
49     unsigned startColumn() const { return m_startColumn; }
50     unsigned endColumn() const { return m_endColumn; }
51     unsigned typeProfilingStartOffset() const { return m_typeProfilingStartOffset; }
52     unsigned typeProfilingEndOffset() const { return m_typeProfilingEndOffset; }
53
54     bool usesEval() const { return m_features & EvalFeature; }
55     bool usesArguments() const { return m_features & ArgumentsFeature; }
56     bool isArrowFunctionContext() const { return m_isArrowFunctionContext; }
57     bool isStrictMode() const { return m_features & StrictModeFeature; }
58     DerivedContextType derivedContextType() const { return static_cast<DerivedContextType>(m_derivedContextType); }
59     EvalContextType evalContextType() const { return static_cast<EvalContextType>(m_evalContextType); }
60
61     ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; }
62         
63     void setNeverInline(bool value) { m_neverInline = value; }
64     void setNeverOptimize(bool value) { m_neverOptimize = value; }
65     void setNeverFTLOptimize(bool value) { m_neverFTLOptimize = value; }
66     void setDidTryToEnterInLoop(bool value) { m_didTryToEnterInLoop = value; }
67     void setCanUseOSRExitFuzzing(bool value) { m_canUseOSRExitFuzzing = value; }
68     bool neverInline() const { return m_neverInline; }
69     bool neverOptimize() const { return m_neverOptimize; }
70     bool neverFTLOptimize() const { return m_neverFTLOptimize; }
71     bool didTryToEnterInLoop() const { return m_didTryToEnterInLoop; }
72     bool isInliningCandidate() const { return !neverInline(); }
73     bool isOkToOptimize() const { return !neverOptimize(); }
74     bool canUseOSRExitFuzzing() const { return m_canUseOSRExitFuzzing; }
75     
76     bool* addressOfDidTryToEnterInLoop() { return &m_didTryToEnterInLoop; }
77
78     CodeFeatures features() const { return m_features; }
79         
80     DECLARE_EXPORT_INFO;
81
82     void recordParse(CodeFeatures features, bool hasCapturedVariables, int firstLine, int lastLine, unsigned startColumn, unsigned endColumn)
83     {
84         m_features = features;
85         m_hasCapturedVariables = hasCapturedVariables;
86         m_firstLine = firstLine;
87         m_lastLine = lastLine;
88         ASSERT(startColumn != UINT_MAX);
89         m_startColumn = startColumn;
90         ASSERT(endColumn != UINT_MAX);
91         m_endColumn = endColumn;
92     }
93
94     void installCode(CodeBlock*);
95     void installCode(VM&, CodeBlock*, CodeType, CodeSpecializationKind);
96     CodeBlock* newCodeBlockFor(CodeSpecializationKind, JSFunction*, JSScope*, JSObject*& exception);
97     CodeBlock* newReplacementCodeBlockFor(CodeSpecializationKind);
98
99     // This function has an interesting GC story. Callers of this function are asking us to create a CodeBlock
100     // that is not jettisoned before this function returns. Callers are essentially asking for a strong reference
101     // to the CodeBlock. Because the Executable may be allocating the CodeBlock, we require callers to pass in
102     // their CodeBlock*& reference because it's safe for CodeBlock to be jettisoned if Executable is the only thing
103     // to point to it. This forces callers to have a CodeBlock* in a register or on the stack that will be marked
104     // by conservative GC if a GC happens after we create the CodeBlock.
105     template <typename ExecutableType>
106     JSObject* prepareForExecution(VM&, JSFunction*, JSScope*, CodeSpecializationKind, CodeBlock*& resultCodeBlock);
107
108     template <typename Functor> void forEachCodeBlock(Functor&&);
109
110 private:
111     friend class ExecutableBase;
112     JSObject* prepareForExecutionImpl(VM&, JSFunction*, JSScope*, CodeSpecializationKind, CodeBlock*&);
113
114 protected:
115     ScriptExecutable(Structure*, VM&, const SourceCode&, bool isInStrictContext, DerivedContextType, bool isInArrowFunctionContext, EvalContextType, Intrinsic);
116
117     void finishCreation(VM& vm)
118     {
119         Base::finishCreation(vm);
120         vm.heap.addExecutable(this); // Balanced by Heap::deleteUnmarkedCompiledCode().
121
122 #if ENABLE(CODEBLOCK_SAMPLING)
123         if (SamplingTool* sampler = vm.interpreter->sampler())
124             sampler->notifyOfScope(vm, this);
125 #endif
126     }
127
128     CodeFeatures m_features;
129     bool m_didTryToEnterInLoop;
130     bool m_hasCapturedVariables : 1;
131     bool m_neverInline : 1;
132     bool m_neverOptimize : 1;
133     bool m_neverFTLOptimize : 1;
134     bool m_isArrowFunctionContext : 1;
135     bool m_canUseOSRExitFuzzing : 1;
136     unsigned m_derivedContextType : 2; // DerivedContextType
137     unsigned m_evalContextType : 2; // EvalContextType
138
139     int m_overrideLineNumber;
140     int m_firstLine;
141     int m_lastLine;
142     unsigned m_startColumn;
143     unsigned m_endColumn;
144     unsigned m_typeProfilingStartOffset;
145     unsigned m_typeProfilingEndOffset;
146     SourceCode m_source;
147 };
148
149 } // namespace JSC