/* -*- 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/AsmJS.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
{
    Rooted<const LazyScript*> self(cx, this);
    if (self->function_ && !self->function_->getOrCreateScript(cx))
        return nullptr;
    return self->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)
{
    return &getObject(index)->as<js::RegExpObject>();
}

inline js::RegExpObject*
JSScript::getRegExp(jsbytecode* pc)
{
    return &getObject(pc)->as<js::RegExpObject>();
}

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(JSRuntime* maybeRuntime, js::jit::BaselineScript* baselineScript)
{
    if (hasBaselineScript())
        js::jit::BaselineScript::writeBarrierPre(zone(), baseline);
    MOZ_ASSERT(!hasIonScript());
    baseline = baselineScript;
    resetWarmUpResetCounter();
    updateBaselineOrIonRaw(maybeRuntime);
}

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 */