mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
217 lines
5.0 KiB
C++
217 lines
5.0 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef jsscriptinlines_h
|
|
#define jsscriptinlines_h
|
|
|
|
#include "jsscript.h"
|
|
|
|
#include "asmjs/AsmJSLink.h"
|
|
#include "jit/BaselineJIT.h"
|
|
#include "jit/IonAnalysis.h"
|
|
#include "vm/ScopeObject.h"
|
|
|
|
#include "jscompartmentinlines.h"
|
|
|
|
#include "vm/Shape-inl.h"
|
|
|
|
namespace js {
|
|
|
|
inline
|
|
AliasedFormalIter::AliasedFormalIter(JSScript* script)
|
|
: begin_(script->bindingArray()),
|
|
p_(begin_),
|
|
end_(begin_ + (script->funHasAnyAliasedFormal() ? script->numArgs() : 0)),
|
|
slot_(CallObject::RESERVED_SLOTS)
|
|
{
|
|
settle();
|
|
}
|
|
|
|
ScriptCounts::ScriptCounts()
|
|
: pcCounts_(),
|
|
throwCounts_(),
|
|
ionCounts_(nullptr)
|
|
{
|
|
}
|
|
|
|
ScriptCounts::ScriptCounts(PCCountsVector&& jumpTargets)
|
|
: pcCounts_(Move(jumpTargets)),
|
|
throwCounts_(),
|
|
ionCounts_(nullptr)
|
|
{
|
|
}
|
|
|
|
ScriptCounts::ScriptCounts(ScriptCounts&& src)
|
|
: pcCounts_(Move(src.pcCounts_)),
|
|
throwCounts_(Move(src.throwCounts_)),
|
|
ionCounts_(Move(src.ionCounts_))
|
|
{
|
|
src.ionCounts_ = nullptr;
|
|
}
|
|
|
|
ScriptCounts&
|
|
ScriptCounts::operator=(ScriptCounts&& src)
|
|
{
|
|
pcCounts_ = Move(src.pcCounts_);
|
|
throwCounts_ = Move(src.throwCounts_);
|
|
ionCounts_ = Move(src.ionCounts_);
|
|
src.ionCounts_ = nullptr;
|
|
return *this;
|
|
}
|
|
|
|
ScriptCounts::~ScriptCounts()
|
|
{
|
|
js_delete(ionCounts_);
|
|
}
|
|
|
|
ScriptAndCounts::ScriptAndCounts(JSScript* script)
|
|
: script(script),
|
|
scriptCounts()
|
|
{
|
|
script->releaseScriptCounts(&scriptCounts);
|
|
}
|
|
|
|
ScriptAndCounts::ScriptAndCounts(ScriptAndCounts&& sac)
|
|
: script(Move(sac.script)),
|
|
scriptCounts(Move(sac.scriptCounts))
|
|
{
|
|
}
|
|
|
|
void
|
|
SetFrameArgumentsObject(JSContext* cx, AbstractFramePtr frame,
|
|
HandleScript script, JSObject* argsobj);
|
|
|
|
inline JSFunction*
|
|
LazyScript::functionDelazifying(JSContext* cx) const
|
|
{
|
|
if (function_ && !function_->getOrCreateScript(cx))
|
|
return nullptr;
|
|
return function_;
|
|
}
|
|
|
|
} // namespace js
|
|
|
|
inline JSFunction*
|
|
JSScript::functionDelazifying() const
|
|
{
|
|
if (function_ && function_->isInterpretedLazy()) {
|
|
function_->setUnlazifiedScript(const_cast<JSScript*>(this));
|
|
// If this script has a LazyScript, make sure the LazyScript has a
|
|
// reference to the script when delazifying its canonical function.
|
|
if (lazyScript && !lazyScript->maybeScript())
|
|
lazyScript->initScript(const_cast<JSScript*>(this));
|
|
}
|
|
return function_;
|
|
}
|
|
|
|
inline void
|
|
JSScript::setFunction(JSFunction* fun)
|
|
{
|
|
MOZ_ASSERT(!function_ && !module_);
|
|
MOZ_ASSERT(fun->isTenured());
|
|
function_ = fun;
|
|
}
|
|
|
|
inline void
|
|
JSScript::setModule(js::ModuleObject* module)
|
|
{
|
|
MOZ_ASSERT(!function_ && !module_);
|
|
module_ = module;
|
|
}
|
|
|
|
inline void
|
|
JSScript::ensureNonLazyCanonicalFunction(JSContext* cx)
|
|
{
|
|
// Infallibly delazify the canonical script.
|
|
if (function_ && function_->isInterpretedLazy())
|
|
functionDelazifying();
|
|
}
|
|
|
|
inline JSFunction*
|
|
JSScript::getFunction(size_t index)
|
|
{
|
|
JSFunction* fun = &getObject(index)->as<JSFunction>();
|
|
MOZ_ASSERT_IF(fun->isNative(), IsAsmJSModuleNative(fun->native()));
|
|
return fun;
|
|
}
|
|
|
|
inline JSFunction*
|
|
JSScript::getCallerFunction()
|
|
{
|
|
MOZ_ASSERT(savedCallerFun());
|
|
return getFunction(0);
|
|
}
|
|
|
|
inline JSFunction*
|
|
JSScript::functionOrCallerFunction()
|
|
{
|
|
if (functionNonDelazifying())
|
|
return functionNonDelazifying();
|
|
if (savedCallerFun())
|
|
return getCallerFunction();
|
|
return nullptr;
|
|
}
|
|
|
|
inline js::RegExpObject*
|
|
JSScript::getRegExp(size_t index)
|
|
{
|
|
js::ObjectArray* arr = regexps();
|
|
MOZ_ASSERT(uint32_t(index) < arr->length);
|
|
JSObject* obj = arr->vector[index];
|
|
MOZ_ASSERT(obj->is<js::RegExpObject>());
|
|
return (js::RegExpObject*) obj;
|
|
}
|
|
|
|
inline js::RegExpObject*
|
|
JSScript::getRegExp(jsbytecode* pc)
|
|
{
|
|
MOZ_ASSERT(containsPC(pc) && containsPC(pc + sizeof(uint32_t)));
|
|
return getRegExp(GET_UINT32_INDEX(pc));
|
|
}
|
|
|
|
inline js::GlobalObject&
|
|
JSScript::global() const
|
|
{
|
|
/*
|
|
* A JSScript always marks its compartment's global (via bindings) so we
|
|
* can assert that maybeGlobal is non-null here.
|
|
*/
|
|
return *compartment()->maybeGlobal();
|
|
}
|
|
|
|
inline JSPrincipals*
|
|
JSScript::principals()
|
|
{
|
|
return compartment()->principals();
|
|
}
|
|
|
|
inline void
|
|
JSScript::setBaselineScript(JSContext* maybecx, js::jit::BaselineScript* baselineScript)
|
|
{
|
|
if (hasBaselineScript())
|
|
js::jit::BaselineScript::writeBarrierPre(zone(), baseline);
|
|
MOZ_ASSERT(!hasIonScript());
|
|
baseline = baselineScript;
|
|
resetWarmUpResetCounter();
|
|
updateBaselineOrIonRaw(maybecx);
|
|
}
|
|
|
|
inline bool
|
|
JSScript::ensureHasAnalyzedArgsUsage(JSContext* cx)
|
|
{
|
|
if (analyzedArgsUsage())
|
|
return true;
|
|
return js::jit::AnalyzeArgumentsUsage(cx, this);
|
|
}
|
|
|
|
inline bool
|
|
JSScript::isDebuggee() const
|
|
{
|
|
return compartment_->debuggerObservesAllExecution() || hasDebugScript_;
|
|
}
|
|
|
|
#endif /* jsscriptinlines_h */
|