[JSC] Remove gcc warnings on mips and armv7
[WebKit-https.git] / Source / JavaScriptCore / runtime / ScriptExecutable.h
1 /*
2  * Copyright (C) 2009-2018 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 IsoCellSet;
33
34 class ScriptExecutable : public ExecutableBase {
35 public:
36     typedef ExecutableBase Base;
37     static const unsigned StructureFlags = Base::StructureFlags;
38
39     static void destroy(JSCell*);
40         
41     CodeBlockHash hashFor(CodeSpecializationKind) const;
42
43     const SourceCode& source() const { return m_source; }
44     intptr_t sourceID() const { return m_source.providerID(); }
45     const SourceOrigin& sourceOrigin() const { return m_source.provider()->sourceOrigin(); }
46     const String& sourceURL() const { return m_source.provider()->url(); }
47     int firstLine() const { return m_source.firstLine().oneBasedInt(); }
48     void setOverrideLineNumber(int overrideLineNumber) { m_overrideLineNumber = overrideLineNumber; }
49     bool hasOverrideLineNumber() const { return m_overrideLineNumber != -1; }
50     int overrideLineNumber() const { return m_overrideLineNumber; }
51     int lastLine() const { return m_lastLine; }
52     unsigned startColumn() const { return m_source.startColumn().oneBasedInt(); }
53     unsigned endColumn() const { return m_endColumn; }
54     unsigned typeProfilingStartOffset() const { return m_typeProfilingStartOffset; }
55     unsigned typeProfilingEndOffset() const { return m_typeProfilingEndOffset; }
56
57     bool usesEval() const { return m_features & EvalFeature; }
58     bool usesArguments() const { return m_features & ArgumentsFeature; }
59     bool isArrowFunctionContext() const { return m_isArrowFunctionContext; }
60     bool isStrictMode() const { return m_features & StrictModeFeature; }
61     DerivedContextType derivedContextType() const { return static_cast<DerivedContextType>(m_derivedContextType); }
62     EvalContextType evalContextType() const { return static_cast<EvalContextType>(m_evalContextType); }
63
64     ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; }
65         
66     void setNeverInline(bool value) { m_neverInline = value; }
67     void setNeverOptimize(bool value) { m_neverOptimize = value; }
68     void setNeverFTLOptimize(bool value) { m_neverFTLOptimize = value; }
69     void setDidTryToEnterInLoop(bool value) { m_didTryToEnterInLoop = value; }
70     void setCanUseOSRExitFuzzing(bool value) { m_canUseOSRExitFuzzing = value; }
71     bool neverInline() const { return m_neverInline; }
72     bool neverOptimize() const { return m_neverOptimize; }
73     bool neverFTLOptimize() const { return m_neverFTLOptimize; }
74     bool didTryToEnterInLoop() const { return m_didTryToEnterInLoop; }
75     bool isInliningCandidate() const { return !neverInline(); }
76     bool isOkToOptimize() const { return !neverOptimize(); }
77     bool canUseOSRExitFuzzing() const { return m_canUseOSRExitFuzzing; }
78     
79     bool* addressOfDidTryToEnterInLoop() { return &m_didTryToEnterInLoop; }
80
81     CodeFeatures features() const { return m_features; }
82         
83     DECLARE_EXPORT_INFO;
84
85     void recordParse(CodeFeatures features, bool hasCapturedVariables, int lastLine, unsigned endColumn)
86     {
87         m_features = features;
88         m_hasCapturedVariables = hasCapturedVariables;
89         m_lastLine = lastLine;
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     void clearCode(IsoCellSet&);
100
101     // This function has an interesting GC story. Callers of this function are asking us to create a CodeBlock
102     // that is not jettisoned before this function returns. Callers are essentially asking for a strong reference
103     // to the CodeBlock. Because the Executable may be allocating the CodeBlock, we require callers to pass in
104     // their CodeBlock*& reference because it's safe for CodeBlock to be jettisoned if Executable is the only thing
105     // to point to it. This forces callers to have a CodeBlock* in a register or on the stack that will be marked
106     // by conservative GC if a GC happens after we create the CodeBlock.
107     template <typename ExecutableType>
108     std::optional<Exception*> prepareForExecution(VM&, JSFunction*, JSScope*, CodeSpecializationKind, CodeBlock*& resultCodeBlock);
109
110 private:
111     friend class ExecutableBase;
112     std::optional<Exception*> 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
121 #if ENABLE(CODEBLOCK_SAMPLING)
122         if (SamplingTool* sampler = vm.interpreter->sampler())
123             sampler->notifyOfScope(vm, this);
124 #endif
125     }
126
127     CodeFeatures m_features;
128     bool m_didTryToEnterInLoop;
129     bool m_hasCapturedVariables : 1;
130     bool m_neverInline : 1;
131     bool m_neverOptimize : 1;
132     bool m_neverFTLOptimize : 1;
133     bool m_isArrowFunctionContext : 1;
134     bool m_canUseOSRExitFuzzing : 1;
135     unsigned m_derivedContextType : 2; // DerivedContextType
136     unsigned m_evalContextType : 2; // EvalContextType
137
138     int m_overrideLineNumber;
139     int m_lastLine;
140     unsigned m_endColumn;
141     unsigned m_typeProfilingStartOffset;
142     unsigned m_typeProfilingEndOffset;
143     SourceCode m_source;
144 };
145
146 } // namespace JSC