qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/src/qml/compiler/qv4compilercontext.cpp

436 lines
16 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qv4compilercontext_p.h"
#include "qv4compilercontrolflow_p.h"
#include "qv4bytecodegenerator_p.h"
QT_USE_NAMESPACE
using namespace QV4;
using namespace QV4::Compiler;
using namespace QQmlJS::AST;
QT_BEGIN_NAMESPACE
Context *Module::newContext(Node *node, Context *parent, ContextType contextType)
{
Q_ASSERT(!contextMap.contains(node));
Context *c = new Context(parent, contextType);
if (node) {
SourceLocation loc = node->firstSourceLocation();
c->line = loc.startLine;
c->column = loc.startColumn;
}
contextMap.insert(node, c);
if (!parent)
rootContext = c;
else {
parent->nestedContexts.append(c);
c->isStrict = parent->isStrict;
}
return c;
}
bool Context::Member::requiresTDZCheck(const SourceLocation &accessLocation, bool accessAcrossContextBoundaries) const
{
if (!isLexicallyScoped())
return false;
if (accessAcrossContextBoundaries)
return true;
if (!accessLocation.isValid() || !endOfInitializerLocation.isValid())
return true;
return accessLocation.begin() < endOfInitializerLocation.end();
}
bool Context::addLocalVar(const QString &name, Context::MemberType type, VariableScope scope, FunctionExpression *function,
const QQmlJS::AST::SourceLocation &endOfInitializer)
{
// ### can this happen?
if (name.isEmpty())
return true;
if (type != FunctionDefinition) {
if (formals && formals->containsName(name))
return (scope == VariableScope::Var);
}
if (!isCatchBlock || name != caughtVariable) {
MemberMap::iterator it = members.find(name);
if (it != members.end()) {
if (scope != VariableScope::Var || (*it).scope != VariableScope::Var)
return false;
if ((*it).type <= type) {
(*it).type = type;
(*it).function = function;
}
return true;
}
}
// hoist var declarations to the function level
if (contextType == ContextType::Block && (scope == VariableScope::Var && type != MemberType::FunctionDefinition))
return parent->addLocalVar(name, type, scope, function, endOfInitializer);
Member m;
m.type = type;
m.function = function;
m.scope = scope;
m.endOfInitializerLocation = endOfInitializer;
members.insert(name, m);
return true;
}
Context::ResolvedName Context::resolveName(const QString &name, const QQmlJS::AST::SourceLocation &accessLocation)
{
int scope = 0;
Context *c = this;
ResolvedName result;
while (c) {
if (c->isWithBlock)
return result;
Context::Member m = c->findMember(name);
if (!c->parent && m.index < 0)
break;
if (m.type != Context::UndefinedMember) {
result.type = m.canEscape ? ResolvedName::Local : ResolvedName::Stack;
result.scope = scope;
result.index = m.index;
result.isConst = (m.scope == VariableScope::Const);
result.requiresTDZCheck = m.requiresTDZCheck(accessLocation, c != this);
if (c->isStrict && (name == QLatin1String("arguments") || name == QLatin1String("eval")))
result.isArgOrEval = true;
return result;
}
const int argIdx = c->findArgument(name);
if (argIdx != -1) {
if (c->argumentsCanEscape) {
result.index = argIdx + c->locals.size();
result.scope = scope;
result.type = ResolvedName::Local;
result.isConst = false;
return result;
} else {
result.index = argIdx + sizeof(CallData)/sizeof(Value) - 1;
result.scope = 0;
result.type = ResolvedName::Stack;
result.isConst = false;
return result;
}
}
if (c->hasDirectEval) {
Q_ASSERT(!c->isStrict && c->contextType != ContextType::Block);
return result;
}
if (c->requiresExecutionContext)
++scope;
c = c->parent;
}
if (c && c->contextType == ContextType::ESModule) {
for (int i = 0; i < c->importEntries.count(); ++i) {
if (c->importEntries.at(i).localName == name) {
result.index = i;
result.type = ResolvedName::Import;
result.isConst = true;
// We don't know at compile time whether the imported value is let/const or not.
result.requiresTDZCheck = true;
return result;
}
}
}
// ### can we relax the restrictions here?
if (c->contextType == ContextType::Eval)
return result;
if (c->contextType == ContextType::Binding || c->contextType == ContextType::ScriptImportedByQML)
result.type = ResolvedName::QmlGlobal;
else
result.type = ResolvedName::Global;
return result;
}
void Context::emitBlockHeader(Codegen *codegen)
{
using Instruction = Moth::Instruction;
Moth::BytecodeGenerator *bytecodeGenerator = codegen->generator();
setupFunctionIndices(bytecodeGenerator);
if (requiresExecutionContext) {
if (blockIndex < 0) {
codegen->module()->blocks.append(this);
blockIndex = codegen->module()->blocks.count() - 1;
}
if (contextType == ContextType::Global) {
Instruction::PushScriptContext scriptContext;
scriptContext.index = blockIndex;
bytecodeGenerator->addInstruction(scriptContext);
} else if (contextType == ContextType::Block || (contextType == ContextType::Eval && !isStrict)) {
if (isCatchBlock) {
Instruction::PushCatchContext catchContext;
catchContext.index = blockIndex;
catchContext.name = codegen->registerString(caughtVariable);
bytecodeGenerator->addInstruction(catchContext);
} else {
Instruction::PushBlockContext blockContext;
blockContext.index = blockIndex;
bytecodeGenerator->addInstruction(blockContext);
}
} else if (contextType != ContextType::ESModule && contextType != ContextType::ScriptImportedByQML) {
Instruction::CreateCallContext createContext;
bytecodeGenerator->addInstruction(createContext);
}
}
if (contextType == ContextType::Block && sizeOfRegisterTemporalDeadZone > 0) {
Instruction::InitializeBlockDeadTemporalZone tdzInit;
tdzInit.firstReg = registerOffset + nRegisters - sizeOfRegisterTemporalDeadZone;
tdzInit.count = sizeOfRegisterTemporalDeadZone;
bytecodeGenerator->addInstruction(tdzInit);
}
if (usesThis) {
Q_ASSERT(!isStrict);
// make sure we convert this to an object
Instruction::ConvertThisToObject convert;
bytecodeGenerator->addInstruction(convert);
}
if (innerFunctionAccessesThis) {
Instruction::LoadReg load;
load.reg = CallData::This;
bytecodeGenerator->addInstruction(load);
Codegen::Reference r = codegen->referenceForName(QStringLiteral("this"), true);
r.storeConsumeAccumulator();
}
if (innerFunctionAccessesNewTarget) {
Instruction::LoadReg load;
load.reg = CallData::NewTarget;
bytecodeGenerator->addInstruction(load);
Codegen::Reference r = codegen->referenceForName(QStringLiteral("new.target"), true);
r.storeConsumeAccumulator();
}
if (contextType == ContextType::Global || contextType == ContextType::ScriptImportedByQML || (contextType == ContextType::Eval && !isStrict)) {
// variables in global code are properties of the global context object, not locals as with other functions.
for (Context::MemberMap::const_iterator it = members.constBegin(), cend = members.constEnd(); it != cend; ++it) {
if (it->isLexicallyScoped())
continue;
const QString &local = it.key();
Instruction::DeclareVar declareVar;
declareVar.isDeletable = (contextType == ContextType::Eval);
declareVar.varName = codegen->registerString(local);
bytecodeGenerator->addInstruction(declareVar);
}
}
if (contextType == ContextType::Function || contextType == ContextType::Binding || contextType == ContextType::ESModule) {
for (Context::MemberMap::iterator it = members.begin(), end = members.end(); it != end; ++it) {
if (it->canEscape && it->type == Context::ThisFunctionName) {
// move the function from the stack to the call context
Instruction::LoadReg load;
load.reg = CallData::Function;
bytecodeGenerator->addInstruction(load);
Instruction::StoreLocal store;
store.index = it->index;
bytecodeGenerator->addInstruction(store);
}
}
}
if (usesArgumentsObject == Context::ArgumentsObjectUsed) {
Q_ASSERT(contextType != ContextType::Block);
if (isStrict || (formals && !formals->isSimpleParameterList())) {
Instruction::CreateUnmappedArgumentsObject setup;
bytecodeGenerator->addInstruction(setup);
} else {
Instruction::CreateMappedArgumentsObject setup;
bytecodeGenerator->addInstruction(setup);
}
codegen->referenceForName(QStringLiteral("arguments"), false).storeConsumeAccumulator();
}
for (const Context::Member &member : qAsConst(members)) {
if (member.function) {
const int function = codegen->defineFunction(member.function->name.toString(), member.function, member.function->formals, member.function->body);
codegen->loadClosure(function);
Codegen::Reference r = codegen->referenceForName(member.function->name.toString(), true);
r.storeConsumeAccumulator();
}
}
}
void Context::emitBlockFooter(Codegen *codegen)
{
using Instruction = Moth::Instruction;
Moth::BytecodeGenerator *bytecodeGenerator = codegen->generator();
if (!requiresExecutionContext)
return;
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized") // the loads below are empty structs.
if (contextType == ContextType::Global)
bytecodeGenerator->addInstruction(Instruction::PopScriptContext());
else if (contextType != ContextType::ESModule && contextType != ContextType::ScriptImportedByQML)
bytecodeGenerator->addInstruction(Instruction::PopContext());
QT_WARNING_POP
}
void Context::setupFunctionIndices(Moth::BytecodeGenerator *bytecodeGenerator)
{
if (registerOffset != -1) {
// already computed, check for consistency
Q_ASSERT(registerOffset == bytecodeGenerator->currentRegister());
bytecodeGenerator->newRegisterArray(nRegisters);
return;
}
Q_ASSERT(locals.size() == 0);
Q_ASSERT(nRegisters == 0);
registerOffset = bytecodeGenerator->currentRegister();
QVector<Context::MemberMap::Iterator> localsInTDZ;
const auto registerLocal = [this, &localsInTDZ](Context::MemberMap::iterator member) {
if (member->isLexicallyScoped()) {
localsInTDZ << member;
} else {
member->index = locals.size();
locals.append(member.key());
}
};
QVector<Context::MemberMap::Iterator> registersInTDZ;
const auto allocateRegister = [bytecodeGenerator, &registersInTDZ](Context::MemberMap::iterator member) {
if (member->isLexicallyScoped())
registersInTDZ << member;
else
member->index = bytecodeGenerator->newRegister();
};
switch (contextType) {
case ContextType::ESModule:
case ContextType::Block:
case ContextType::Function:
case ContextType::Binding: {
for (Context::MemberMap::iterator it = members.begin(), end = members.end(); it != end; ++it) {
if (it->canEscape) {
registerLocal(it);
} else {
if (it->type == Context::ThisFunctionName)
it->index = CallData::Function;
else
allocateRegister(it);
}
}
break;
}
case ContextType::Global:
case ContextType::ScriptImportedByQML:
case ContextType::Eval:
for (Context::MemberMap::iterator it = members.begin(), end = members.end(); it != end; ++it) {
if (!it->isLexicallyScoped() && (contextType == ContextType::Global || contextType == ContextType::ScriptImportedByQML || !isStrict))
continue;
if (it->canEscape)
registerLocal(it);
else
allocateRegister(it);
}
break;
}
sizeOfLocalTemporalDeadZone = localsInTDZ.count();
for (auto &member: qAsConst(localsInTDZ)) {
member->index = locals.size();
locals.append(member.key());
}
if (contextType == ContextType::ESModule && !localNameForDefaultExport.isEmpty()) {
if (!members.contains(localNameForDefaultExport)) {
// allocate a local slot for the default export, to be used in
// CodeGen::visit(ExportDeclaration*).
locals.append(localNameForDefaultExport);
++sizeOfLocalTemporalDeadZone;
}
}
sizeOfRegisterTemporalDeadZone = registersInTDZ.count();
firstTemporalDeadZoneRegister = bytecodeGenerator->currentRegister();
for (auto &member: qAsConst(registersInTDZ))
member->index = bytecodeGenerator->newRegister();
nRegisters = bytecodeGenerator->currentRegister() - registerOffset;
}
bool Context::canUseTracingJit() const
{
#if QT_CONFIG(qml_tracing)
static bool forceTracing = !qEnvironmentVariableIsEmpty("QV4_FORCE_TRACING");
if (forceTracing) //### we can probably remove this when tracing is turned on by default
return true; // to be used by unittests
static bool disableTracing = !qEnvironmentVariableIsEmpty("QV4_DISABLE_TRACING");
if (disableTracing)
return false;
static QStringList onlyTrace =
qEnvironmentVariable("QV4_ONLY_TRACE").split(QLatin1Char(','), QString::SkipEmptyParts);
if (!onlyTrace.isEmpty())
return onlyTrace.contains(name);
return true;
#else
return false;
#endif
}
QT_END_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink