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/qv4instr_moth.cpp

523 lines
16 KiB
C++
Raw Normal View History

Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
/****************************************************************************
**
Updated license headers From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new LGPL header instead of LGPL21 one (in those files which will be under LGPL v3) Change-Id: Ic36f1a0a1436fe6ac6eeca8c2375a79857e9cb12 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 09:38:36 +00:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
**
Fix module name (QtQml) in the license header Change-Id: Id78dfee1ac76a3b4d0976864353c4eb50e63c08b Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-06-24 11:50:51 +00:00
** This file is part of the QtQml module of the Qt Toolkit.
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
**
Updated license headers From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new LGPL header instead of LGPL21 one (in those files which will be under LGPL v3) Change-Id: Ic36f1a0a1436fe6ac6eeca8c2375a79857e9cb12 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 09:38:36 +00:00
** $QT_BEGIN_LICENSE:LGPL$
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
** 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
Update copyright headers Qt copyrights are now in The Qt Company, so we could update the source code headers accordingly. In the same go we should also fix the links to point to qt.io. Change-Id: I61120571787870c0ed17066afb31779b1e6e30e9 Reviewed-by: Iikka Eklund <iikka.eklund@theqtcompany.com>
2015-01-28 11:55:39 +00:00
** a written agreement between you and The Qt Company. For licensing terms
Updated license headers From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new LGPL header instead of LGPL21 one (in those files which will be under LGPL v3) Change-Id: Ic36f1a0a1436fe6ac6eeca8c2375a79857e9cb12 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 09:38:36 +00:00
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
Updated license headers From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new LGPL header instead of LGPL21 one (in those files which will be under LGPL v3) Change-Id: Ic36f1a0a1436fe6ac6eeca8c2375a79857e9cb12 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 09:38:36 +00:00
** 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.
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
**
Updated license headers From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new LGPL header instead of LGPL21 one (in those files which will be under LGPL v3) Change-Id: Ic36f1a0a1436fe6ac6eeca8c2375a79857e9cb12 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 09:38:36 +00:00
** 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.
Fix some missing license headers Change-Id: I758fe0a61d1ecb9418087ac318ac93f227013248 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-06-24 10:07:48 +00:00
**
** $QT_END_LICENSE$
**
****************************************************************************/
Add moth skeleton
2012-06-08 19:09:13 +00:00
#include "qv4instr_moth_p.h"
Clean up our internal namespaces QQmlJS::MASM -> QV4::JIT QQmlJS::V4IR -> QV4::IR Change-Id: I707e8990459114a699c200fe3c22cec3c8df1afc Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-14 12:58:40 +00:00
using namespace QV4;
using namespace QV4::Moth;
Add moth skeleton
2012-06-08 19:09:13 +00:00
int Instr::size(Type type)
{
#define MOTH_RETURN_INSTR_SIZE(I, FMT) case I: return InstrMeta<(int)I>::Size;
switch (type) {
FOR_EACH_MOTH_INSTR(MOTH_RETURN_INSTR_SIZE)
default: return 0;
}
#undef MOTH_RETURN_INSTR_SIZE
}
Encode numeric literals as int when possible Change-Id: I5ecc406f06a193b470eb9ac376da6b9f752d01cb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 09:16:11 +00:00
static QByteArray alignedNumber(int n) {
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
QByteArray number = QByteArray::number(n);
while (number.size() < 12)
number.prepend(' ');
return number;
}
Encode numeric literals as int when possible Change-Id: I5ecc406f06a193b470eb9ac376da6b9f752d01cb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 09:16:11 +00:00
static QString toString(QV4::ReturnedValue v)
Implement support for conditional expressions Change-Id: Ifcd57713e1cfa9514d3955e26f739a359cdaa8e5 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-13 20:51:51 +00:00
{
#ifdef V4_BOOTSTRAP
return QStringLiteral("string-const(%1)").arg(v);
#else // !V4_BOOTSTRAP
Value val = Value::fromReturnedValue(v);
Encode numeric literals as int when possible Change-Id: I5ecc406f06a193b470eb9ac376da6b9f752d01cb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 09:16:11 +00:00
QString result;
if (val.isInt32())
result = QLatin1String("int ");
else if (val.isDouble())
result = QLatin1String("double ");
if (val.isEmpty())
result += QLatin1String("empty");
else
result += val.toQStringNoThrow();
Add constant table dumping Change-Id: I1e3728481dab97b264f19f84edd602f9eae66983 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 12:28:47 +00:00
return result;
Implement support for conditional expressions Change-Id: Ifcd57713e1cfa9514d3955e26f739a359cdaa8e5 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-13 20:51:51 +00:00
#endif // V4_BOOTSTRAP
}
Dump absolute addresses for jumps Change-Id: I503496c66fab067cb28f360cd10c9da5682384ab Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-14 11:58:38 +00:00
template<typename T>
int absoluteInstructionOffset(const char *codeStart, const T &instr)
{
return reinterpret_cast<const char *>(&instr) - codeStart + offsetof(T, offset) + instr.offset;
}
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
#define MOTH_BEGIN_INSTR(I) \
case Instr::I: {\
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
const InstrMeta<int(Instr::I)>::DataType &instr = InstrMeta<int(Instr::I)>::data(*genericInstr); \
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
Q_UNUSED(instr); \
QDebug d = qDebug(); \
d.nospace(); \
Fix various signed/unsigned warnings Change-Id: I9f4a5a8470c1abc6b07a28c71fdad0d208e1fea1 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:43:11 +00:00
d << alignedNumber(int(code - start)).constData() << ": " << #I << " "; \
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
code += InstrMeta<int(Instr::I)>::Size; \
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
#define MOTH_END_INSTR(I) } break;
QT_BEGIN_NAMESPACE
namespace QV4 {
namespace Moth {
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
QDebug operator<<(QDebug dbg, const Temp &t)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
{
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
dbg << "%" << t.index;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
return dbg;
}
Add constant table dumping Change-Id: I1e3728481dab97b264f19f84edd602f9eae66983 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 12:28:47 +00:00
void dumpConstantTable(const Value *constants, uint count)
{
QDebug d = qDebug();
d.nospace();
for (uint i = 0; i < count; ++i)
d << alignedNumber(i).constData() << ": "
<< toString(constants[i].asReturnedValue()).toUtf8().constData() << "\n";
}
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
void dumpBytecode(const char *code, int len)
{
const char *start = code;
const char *end = code + len;
while (code < end) {
const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
switch (genericInstr->common.instructionType) {
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
MOTH_BEGIN_INSTR(LoadReg)
d << instr.reg;
MOTH_END_INSTR(LoadReg)
MOTH_BEGIN_INSTR(StoreReg)
d << instr.reg;
MOTH_END_INSTR(StoreReg)
MOTH_BEGIN_INSTR(MoveReg)
d << instr.destReg << ", " << instr.srcReg;
MOTH_END_INSTR(MoveReg)
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_BEGIN_INSTR(LoadConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "C" << instr.index;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(LoadConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
MOTH_BEGIN_INSTR(MoveConst)
d << instr.destTemp << ", C" << instr.constIndex;
MOTH_END_INSTR(MoveConst)
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_BEGIN_INSTR(LoadLocal)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "$" << instr.index;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(LoadLocal)
MOTH_BEGIN_INSTR(StoreLocal)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "$" << instr.index;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(StoreLocal)
MOTH_BEGIN_INSTR(LoadArg)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "#" << instr.index;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(LoadArg)
MOTH_BEGIN_INSTR(StoreArg)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "#" << instr.index;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(StoreArg)
MOTH_BEGIN_INSTR(LoadScopedLocal)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "$" << instr.index << "@" << instr.scope;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(LoadScopedLocal)
MOTH_BEGIN_INSTR(StoreScopedLocal)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << ", " << "$" << instr.index << "@" << instr.scope;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(StoreScopedLocal)
MOTH_BEGIN_INSTR(LoadScopedArg)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "#" << instr.index << "@" << instr.scope;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(LoadScopedArg)
MOTH_BEGIN_INSTR(StoreScopedArg)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "#" << instr.index << "@" << instr.scope;
Remove Moth::Param from the interpreter instructions The Param struct is now internal to the interpreter loop. It can be removed in a second step so we can directly access constants/temporaries/locals/arguments. Change-Id: I47ecbfe7508f352a8f212af48461dc92b35f4695 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-07-11 14:55:49 +00:00
MOTH_END_INSTR(StoreScopedArg)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(LoadRuntimeString)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.stringId;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadRuntimeString)
MOTH_BEGIN_INSTR(LoadRegExp)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.regExpId;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadRegExp)
MOTH_BEGIN_INSTR(LoadClosure)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.value;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadClosure)
MOTH_BEGIN_INSTR(LoadName)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadName)
MOTH_BEGIN_INSTR(GetGlobalLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.index;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(GetGlobalLookup)
MOTH_BEGIN_INSTR(StoreName)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreName)
MOTH_BEGIN_INSTR(LoadElement)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadElement)
Allow for more values to be in the accumulator For subscript indices and the base of a property name lookup Change-Id: I20394aa5daf6e49137b66575e56d1f8937160a8d Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-21 08:55:35 +00:00
MOTH_BEGIN_INSTR(LoadElementA)
d << instr.base << "[acc]";
MOTH_END_INSTR(LoadElement)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(LoadElementLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadElementLookup)
MOTH_BEGIN_INSTR(StoreElement)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreElement)
MOTH_BEGIN_INSTR(StoreElementLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreElementLookup)
MOTH_BEGIN_INSTR(LoadProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.name << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadProperty)
Allow for more values to be in the accumulator For subscript indices and the base of a property name lookup Change-Id: I20394aa5daf6e49137b66575e56d1f8937160a8d Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-21 08:55:35 +00:00
MOTH_BEGIN_INSTR(LoadPropertyA)
d << "acc[" << instr.name << "]";
MOTH_END_INSTR(LoadElementA)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(GetLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "(" << instr.index << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(GetLookup)
Allow for more values to be in the accumulator For subscript indices and the base of a property name lookup Change-Id: I20394aa5daf6e49137b66575e56d1f8937160a8d Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-21 08:55:35 +00:00
MOTH_BEGIN_INSTR(GetLookupA)
d << "acc(" << instr.index << ")";
MOTH_END_INSTR(GetLookupA)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(StoreProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.name<< "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreProperty)
MOTH_BEGIN_INSTR(SetLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(SetLookup)
MOTH_BEGIN_INSTR(StoreScopeObjectProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.propertyIndex << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreScopeObjectProperty)
MOTH_BEGIN_INSTR(LoadScopeObjectProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.propertyIndex << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadScopeObjectProperty)
MOTH_BEGIN_INSTR(StoreContextObjectProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.propertyIndex << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(StoreContextObjectProperty)
MOTH_BEGIN_INSTR(LoadContextObjectProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.propertyIndex << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadContextObjectProperty)
MOTH_BEGIN_INSTR(LoadIdObject)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadIdObject)
Rename push instruction to InitStackFrame Change-Id: I67f8397686a439cede37b52863d32dc194bee23f Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-21 09:53:59 +00:00
MOTH_BEGIN_INSTR(InitStackFrame)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
d << instr.value;
Rename push instruction to InitStackFrame Change-Id: I67f8397686a439cede37b52863d32dc194bee23f Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-21 09:53:59 +00:00
MOTH_END_INSTR(InitStackFrame)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(CallValue)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.dest << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallValue)
MOTH_BEGIN_INSTR(CallProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base<<"."<<instr.name << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallProperty)
MOTH_BEGIN_INSTR(CallPropertyLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lookupIndex << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallPropertyLookup)
MOTH_BEGIN_INSTR(CallElement)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]" << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallElement)
MOTH_BEGIN_INSTR(CallActivationProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallActivationProperty)
MOTH_BEGIN_INSTR(CallGlobalLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.index << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallGlobalLookup)
MOTH_BEGIN_INSTR(SetExceptionHandler)
Beautify SetExceptionHandler offset printing Change-Id: Ie17b02053894e2f0f72b04304ed091084472fcdd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-29 09:14:36 +00:00
if (instr.offset)
d << absoluteInstructionOffset(start, instr);
else
d << "<null>";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(SetExceptionHandler)
MOTH_BEGIN_INSTR(CallBuiltinThrow)
MOTH_END_INSTR(CallBuiltinThrow)
Fix exception handling Fix all exception handling related test failures in test262. Change-Id: Iba50238627c31705a4878b43abbb8f20f0ecee88 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-20 12:30:03 +00:00
MOTH_BEGIN_INSTR(GetException)
Proper exception handling Implement exception handling, and make it conformant with the spec. Change-Id: I6d8222617180f96f628f18e11444488e50e5c043 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-16 13:30:23 +00:00
MOTH_END_INSTR(HasException)
Fix exception handling Fix all exception handling related test failures in test262. Change-Id: Iba50238627c31705a4878b43abbb8f20f0ecee88 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-20 12:30:03 +00:00
MOTH_BEGIN_INSTR(SetException)
Proper exception handling Implement exception handling, and make it conformant with the spec. Change-Id: I6d8222617180f96f628f18e11444488e50e5c043 Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-16 13:30:23 +00:00
MOTH_END_INSTR(SetExceptionFlag)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(CallBuiltinUnwindException)
MOTH_END_INSTR(CallBuiltinUnwindException)
MOTH_BEGIN_INSTR(CallBuiltinPushCatchScope)
d << instr.name;
MOTH_END_INSTR(CallBuiltinPushCatchScope)
MOTH_BEGIN_INSTR(CallBuiltinPushScope)
MOTH_END_INSTR(CallBuiltinPushScope)
MOTH_BEGIN_INSTR(CallBuiltinPopScope)
MOTH_END_INSTR(CallBuiltinPopScope)
MOTH_BEGIN_INSTR(CallBuiltinForeachIteratorObject)
MOTH_END_INSTR(CallBuiltinForeachIteratorObject)
MOTH_BEGIN_INSTR(CallBuiltinForeachNextPropertyName)
MOTH_END_INSTR(CallBuiltinForeachNextPropertyName)
MOTH_BEGIN_INSTR(CallBuiltinDeleteMember)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.member << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinDeleteMember)
MOTH_BEGIN_INSTR(CallBuiltinDeleteSubscript)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.base << "[" << instr.index << "]";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinDeleteSubscript)
MOTH_BEGIN_INSTR(CallBuiltinDeleteName)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinDeleteName)
MOTH_BEGIN_INSTR(CallBuiltinTypeofName)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinTypeofName)
MOTH_BEGIN_INSTR(CallBuiltinTypeofValue)
MOTH_END_INSTR(CallBuiltinTypeofValue)
MOTH_BEGIN_INSTR(CallBuiltinDeclareVar)
d << instr.isDeletable << ", " << instr.varName;
MOTH_END_INSTR(CallBuiltinDeclareVar)
MOTH_BEGIN_INSTR(CallBuiltinDefineArray)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.args << ", " << instr.argc;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinDefineArray)
MOTH_BEGIN_INSTR(CallBuiltinDefineObjectLiteral)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.args
Make dumped bytecode more readable - change temp/local/formal printing to match the old IR style - add some commas to CallBuiltinDefineObjectLiteral Change-Id: I24b945512969ac1a829e69e3153c433b09215305 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-22 09:17:48 +00:00
<< ", " << instr.internalClassId
<< ", " << instr.arrayValueCount
<< ", " << instr.arrayGetterSetterCountAndFlags;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CallBuiltinDefineObjectLiteral)
MOTH_BEGIN_INSTR(CallBuiltinSetupArgumentsObject)
MOTH_END_INSTR(CallBuiltinSetupArgumentsObject)
MOTH_BEGIN_INSTR(CallBuiltinConvertThisToObject)
MOTH_END_INSTR(CallBuiltinConvertThisToObject)
MOTH_BEGIN_INSTR(CreateValue)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "new" << instr.func << "(" << instr.callData << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CreateValue)
MOTH_BEGIN_INSTR(CreateProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "new" << instr.name << "(" << instr.callData << instr.argc << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CreateProperty)
MOTH_BEGIN_INSTR(ConstructPropertyLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "new" << instr.index << "(" << instr.callData << instr.argc << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(ConstructPropertyLookup)
MOTH_BEGIN_INSTR(CreateActivationProperty)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "new" << instr.name << "(" << instr.callData << instr.argc << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(CreateActivationProperty)
MOTH_BEGIN_INSTR(ConstructGlobalLookup)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "new" << instr.index << "(" << instr.callData << instr.argc << ")";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(ConstructGlobalLookup)
MOTH_BEGIN_INSTR(Jump)
Dump absolute addresses for jumps Change-Id: I503496c66fab067cb28f360cd10c9da5682384ab Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-14 11:58:38 +00:00
d << absoluteInstructionOffset(start, instr);
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Jump)
MOTH_BEGIN_INSTR(JumpEq)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc " << absoluteInstructionOffset(start, instr);
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(JumpEq)
MOTH_BEGIN_INSTR(JumpNe)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc " << absoluteInstructionOffset(start, instr);
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(JumpNe)
Add JumpStrict(Not)Equal instructions to the interpreter These will simplify foreach and switch handling. Change-Id: I7fb67481d7d1b82b03c03fd0987b182ea9542c7a Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-14 11:59:31 +00:00
MOTH_BEGIN_INSTR(JumpStrictEqual)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << " " << absoluteInstructionOffset(start, instr);
Add JumpStrict(Not)Equal instructions to the interpreter These will simplify foreach and switch handling. Change-Id: I7fb67481d7d1b82b03c03fd0987b182ea9542c7a Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-14 11:59:31 +00:00
MOTH_END_INSTR(JumpStrictEqual)
MOTH_BEGIN_INSTR(JumpStrictNotEqual)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << " " << absoluteInstructionOffset(start, instr);
Add JumpStrict(Not)Equal instructions to the interpreter These will simplify foreach and switch handling. Change-Id: I7fb67481d7d1b82b03c03fd0987b182ea9542c7a Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-14 11:59:31 +00:00
MOTH_END_INSTR(JumpStrictNotEqual)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(UNot)
MOTH_END_INSTR(UNot)
MOTH_BEGIN_INSTR(UPlus)
MOTH_END_INSTR(UPlus)
MOTH_BEGIN_INSTR(UMinus)
MOTH_END_INSTR(UMinus)
MOTH_BEGIN_INSTR(UCompl)
MOTH_END_INSTR(UCompl)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
MOTH_BEGIN_INSTR(Increment)
Add support for post increment/decrement Change-Id: Ie3f03a548105fe49d29e3d60bf823435f21b0340 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-20 09:28:27 +00:00
MOTH_END_INSTR(PreIncrement)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
MOTH_BEGIN_INSTR(Decrement)
Add support for post increment/decrement Change-Id: Ie3f03a548105fe49d29e3d60bf823435f21b0340 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-20 09:28:27 +00:00
MOTH_END_INSTR(PreDecrement)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(Binop)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.alu << ", " << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Binop)
MOTH_BEGIN_INSTR(Add)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Add)
MOTH_BEGIN_INSTR(BitAnd)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BitAnd)
MOTH_BEGIN_INSTR(BitOr)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BitOr)
MOTH_BEGIN_INSTR(BitXor)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BitXor)
MOTH_BEGIN_INSTR(Shr)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Shr)
MOTH_BEGIN_INSTR(Shl)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Shl)
MOTH_BEGIN_INSTR(BitAndConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc, " << instr.rhs;
MOTH_END_INSTR(BitAndConst)
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_BEGIN_INSTR(BitOrConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc, " << instr.rhs;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BitOr)
MOTH_BEGIN_INSTR(BitXorConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc, " << instr.rhs;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BitXor)
MOTH_BEGIN_INSTR(ShrConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc, " << instr.rhs;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(ShrConst)
MOTH_BEGIN_INSTR(ShlConst)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << "acc, " << instr.rhs;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(ShlConst)
MOTH_BEGIN_INSTR(Mul)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Mul)
MOTH_BEGIN_INSTR(Sub)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(Sub)
MOTH_BEGIN_INSTR(BinopContext)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.alu << " " << instr.lhs << ", acc";
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(BinopContext)
MOTH_BEGIN_INSTR(Ret)
d << instr.result;
MOTH_END_INSTR(Ret)
#ifndef QT_NO_QML_DEBUGGER
MOTH_BEGIN_INSTR(Debug)
MOTH_END_INSTR(Debug)
MOTH_BEGIN_INSTR(Line)
d << instr.lineNumber;
MOTH_END_INSTR(Line)
#endif // QT_NO_QML_DEBUGGER
MOTH_BEGIN_INSTR(LoadThis)
MOTH_END_INSTR(LoadThis)
MOTH_BEGIN_INSTR(LoadQmlContext)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.result;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadQmlContext)
MOTH_BEGIN_INSTR(LoadQmlImportedScripts)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.result;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadQmlImportedScripts)
MOTH_BEGIN_INSTR(LoadQmlSingleton)
Introduce an accumulator in the interpreter, and change instructions This reduces the number of stores to the stack (for which we need a write-barrier in the future) by keeping the last calculated value in the accumulator register (which is a local variable). In the future we might want to collapse certain common instruction patterns into a super-sized instruction. Change-Id: I02ebed2db957765e994c8f939bf7585894881deb Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-07-18 13:48:21 +00:00
d << instr.name;
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
MOTH_END_INSTR(LoadQmlSingleton)
Switch over to new JS call setup Differences: - push parameters on the stack, including space for CallData members - call instructions calculate the argument start - use temp space above the calldata to evaluate arguments - fewer temporaries are needed when a call is done while generating the arguments of another call - when calling the function, the js stack space above the callData is not used, allowing for optimizations in the future - Array and ObjectLiteral use the same mechanism Change-Id: Id100fa06f12cc9d941b0f90b0b81b8270a8e4f5d Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-06-27 14:06:29 +00:00
default:
Q_UNREACHABLE();
}
Add bytecode dumper Change-Id: Ifd63cf604e66f46329472f82a46d37194a1b39eb Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2017-06-13 10:34:46 +00:00
}
}
}
}
QT_END_NAMESPACE