1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * vim: set ts=8 sts=4 et sw=4 tw=99:
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #ifndef jsscriptinlines_h
8 #define jsscriptinlines_h
9
10 #include "jsscript.h"
11
12 #include "asmjs/AsmJSLink.h"
13 #include "jit/BaselineJIT.h"
14 #include "jit/IonAnalysis.h"
15 #include "vm/ScopeObject.h"
16
17 #include "jscompartmentinlines.h"
18
19 #include "vm/Shape-inl.h"
20
21 namespace js {
22
23 inline
AliasedFormalIter(JSScript * script)24 AliasedFormalIter::AliasedFormalIter(JSScript* script)
25 : begin_(script->bindingArray()),
26 p_(begin_),
27 end_(begin_ + (script->funHasAnyAliasedFormal() ? script->numArgs() : 0)),
28 slot_(CallObject::RESERVED_SLOTS)
29 {
30 settle();
31 }
32
ScriptCounts()33 ScriptCounts::ScriptCounts()
34 : pcCounts_(),
35 throwCounts_(),
36 ionCounts_(nullptr)
37 {
38 }
39
ScriptCounts(PCCountsVector && jumpTargets)40 ScriptCounts::ScriptCounts(PCCountsVector&& jumpTargets)
41 : pcCounts_(Move(jumpTargets)),
42 throwCounts_(),
43 ionCounts_(nullptr)
44 {
45 }
46
ScriptCounts(ScriptCounts && src)47 ScriptCounts::ScriptCounts(ScriptCounts&& src)
48 : pcCounts_(Move(src.pcCounts_)),
49 throwCounts_(Move(src.throwCounts_)),
50 ionCounts_(Move(src.ionCounts_))
51 {
52 src.ionCounts_ = nullptr;
53 }
54
55 ScriptCounts&
56 ScriptCounts::operator=(ScriptCounts&& src)
57 {
58 pcCounts_ = Move(src.pcCounts_);
59 throwCounts_ = Move(src.throwCounts_);
60 ionCounts_ = Move(src.ionCounts_);
61 src.ionCounts_ = nullptr;
62 return *this;
63 }
64
~ScriptCounts()65 ScriptCounts::~ScriptCounts()
66 {
67 js_delete(ionCounts_);
68 }
69
ScriptAndCounts(JSScript * script)70 ScriptAndCounts::ScriptAndCounts(JSScript* script)
71 : script(script),
72 scriptCounts()
73 {
74 script->releaseScriptCounts(&scriptCounts);
75 }
76
ScriptAndCounts(ScriptAndCounts && sac)77 ScriptAndCounts::ScriptAndCounts(ScriptAndCounts&& sac)
78 : script(Move(sac.script)),
79 scriptCounts(Move(sac.scriptCounts))
80 {
81 }
82
83 void
84 SetFrameArgumentsObject(JSContext* cx, AbstractFramePtr frame,
85 HandleScript script, JSObject* argsobj);
86
87 inline JSFunction*
functionDelazifying(JSContext * cx)88 LazyScript::functionDelazifying(JSContext* cx) const
89 {
90 if (function_ && !function_->getOrCreateScript(cx))
91 return nullptr;
92 return function_;
93 }
94
95 } // namespace js
96
97 inline JSFunction*
functionDelazifying()98 JSScript::functionDelazifying() const
99 {
100 if (function_ && function_->isInterpretedLazy()) {
101 function_->setUnlazifiedScript(const_cast<JSScript*>(this));
102 // If this script has a LazyScript, make sure the LazyScript has a
103 // reference to the script when delazifying its canonical function.
104 if (lazyScript && !lazyScript->maybeScript())
105 lazyScript->initScript(const_cast<JSScript*>(this));
106 }
107 return function_;
108 }
109
110 inline void
setFunction(JSFunction * fun)111 JSScript::setFunction(JSFunction* fun)
112 {
113 MOZ_ASSERT(!function_ && !module_);
114 MOZ_ASSERT(fun->isTenured());
115 function_ = fun;
116 }
117
118 inline void
setModule(js::ModuleObject * module)119 JSScript::setModule(js::ModuleObject* module)
120 {
121 MOZ_ASSERT(!function_ && !module_);
122 module_ = module;
123 }
124
125 inline void
ensureNonLazyCanonicalFunction(JSContext * cx)126 JSScript::ensureNonLazyCanonicalFunction(JSContext* cx)
127 {
128 // Infallibly delazify the canonical script.
129 if (function_ && function_->isInterpretedLazy())
130 functionDelazifying();
131 }
132
133 inline JSFunction*
getFunction(size_t index)134 JSScript::getFunction(size_t index)
135 {
136 JSFunction* fun = &getObject(index)->as<JSFunction>();
137 MOZ_ASSERT_IF(fun->isNative(), IsAsmJSModuleNative(fun->native()));
138 return fun;
139 }
140
141 inline JSFunction*
getCallerFunction()142 JSScript::getCallerFunction()
143 {
144 MOZ_ASSERT(savedCallerFun());
145 return getFunction(0);
146 }
147
148 inline JSFunction*
functionOrCallerFunction()149 JSScript::functionOrCallerFunction()
150 {
151 if (functionNonDelazifying())
152 return functionNonDelazifying();
153 if (savedCallerFun())
154 return getCallerFunction();
155 return nullptr;
156 }
157
158 inline js::RegExpObject*
getRegExp(size_t index)159 JSScript::getRegExp(size_t index)
160 {
161 js::ObjectArray* arr = regexps();
162 MOZ_ASSERT(uint32_t(index) < arr->length);
163 JSObject* obj = arr->vector[index];
164 MOZ_ASSERT(obj->is<js::RegExpObject>());
165 return (js::RegExpObject*) obj;
166 }
167
168 inline js::RegExpObject*
getRegExp(jsbytecode * pc)169 JSScript::getRegExp(jsbytecode* pc)
170 {
171 MOZ_ASSERT(containsPC(pc) && containsPC(pc + sizeof(uint32_t)));
172 return getRegExp(GET_UINT32_INDEX(pc));
173 }
174
175 inline js::GlobalObject&
global()176 JSScript::global() const
177 {
178 /*
179 * A JSScript always marks its compartment's global (via bindings) so we
180 * can assert that maybeGlobal is non-null here.
181 */
182 return *compartment()->maybeGlobal();
183 }
184
185 inline JSPrincipals*
principals()186 JSScript::principals()
187 {
188 return compartment()->principals();
189 }
190
191 inline void
setBaselineScript(JSContext * maybecx,js::jit::BaselineScript * baselineScript)192 JSScript::setBaselineScript(JSContext* maybecx, js::jit::BaselineScript* baselineScript)
193 {
194 if (hasBaselineScript())
195 js::jit::BaselineScript::writeBarrierPre(zone(), baseline);
196 MOZ_ASSERT(!hasIonScript());
197 baseline = baselineScript;
198 resetWarmUpResetCounter();
199 updateBaselineOrIonRaw(maybecx);
200 }
201
202 inline bool
ensureHasAnalyzedArgsUsage(JSContext * cx)203 JSScript::ensureHasAnalyzedArgsUsage(JSContext* cx)
204 {
205 if (analyzedArgsUsage())
206 return true;
207 return js::jit::AnalyzeArgumentsUsage(cx, this);
208 }
209
210 inline bool
isDebuggee()211 JSScript::isDebuggee() const
212 {
213 return compartment_->debuggerObservesAllExecution() || hasDebugScript_;
214 }
215
216 #endif /* jsscriptinlines_h */
217