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

597 lines
23 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
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
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
**
** $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 Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#include "qv4vme_moth_p.h"
#include "qv4instr_moth_p.h"
Fix compilation with built-in v4vm JS engine Change-Id: Ieda9267e296acf6392a5461f4cfb9233a7a409a0 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-04-15 09:50:16 +00:00
#include <private/qv4value_p.h>
#include <private/qv4debugging_p.h>
Move QV4::Exception into a separate compilation unit with header file This is in preparation for some platform specific code regarding throwing exceptions, as well as a general cleanup :) Change-Id: I23fb4f12fd09423a1f2cb225145780925002677b Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2013-07-10 13:44:11 +00:00
#include <private/qv4exception_p.h>
Fix integer preserving arithmetics with the interpreter This fixes qqmllanguage and some other auto-tests with the interpreter When adding numbers, make sure to preserve them as integer if left and right hand side are integers. We do this now consistently throughout the runtime by providing fallback implementations of mul/sub/add_int32. Change-Id: I37e24ce14dc676bb072571b57289965ec59999c1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:55:45 +00:00
#include <private/qv4math_p.h>
Add some debugging infrastructure to the interpreter. This currently mainly intended to be useful in a C++ debugger. The infrastructure makes it a lot easier to access (parent) contexts, find function names, etc. Change-Id: I0493d3a3bd4bf5c3a03379c1a2b545ed76862cd5 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-29 13:41:26 +00:00
#include <iostream>
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
Fix alloca usage on Windows On Windows it's _alloca, so provide a wrapping macro in qv4alloca_p.h and use that instead. Change-Id: I675cb7fd09bab3c84c44e56819c0f17a42b3c211 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-08 08:30:40 +00:00
#include "qv4alloca_p.h"
Change the interpreter's stack frame to be allocated with alloca. Change-Id: Ia02ad1af3bb0f429a6078029bf7aaee5a17f3413 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-12-19 10:21:06 +00:00
Added property activation to the interpreter. Change-Id: Icbc900f8d617c8736a5663d19f5691f336bedb30 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-10-23 14:06:52 +00:00
#ifdef DO_TRACE_INSTR
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
# define TRACE_INSTR(I) fprintf(stderr, "executing a %s\n", #I);
Add utility function to print stack traces from lldb/gdb. Change-Id: I81315a1cd6900dbecfc9a39d9dc4256461163921 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-12-04 09:31:31 +00:00
# define TRACE(n, str, ...) { char buf[4096]; snprintf(buf, 4096, str, __VA_ARGS__); fprintf(stderr, " %s : %s\n", #n, buf); }
Added property activation to the interpreter. Change-Id: Icbc900f8d617c8736a5663d19f5691f336bedb30 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-10-23 14:06:52 +00:00
#else
# define TRACE_INSTR(I)
# define TRACE(n, str, ...)
#endif // DO_TRACE_INSTR
Add tracing for runtime methods. Change-Id: I540297e83e3e297d0724c3e08e5780eee0d2fac8 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:31:02 +00:00
using namespace QQmlJS;
using namespace QQmlJS::Moth;
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#define MOTH_BEGIN_INSTR_COMMON(I) { \
const InstrMeta<(int)Instr::I>::DataType &instr = InstrMeta<(int)Instr::I>::data(*genericInstr); \
code += InstrMeta<(int)Instr::I>::Size; \
Initial support for debugging in the v4 interpreter This adds breakpoint support to the Debugger, a helper function in the engine for enabling debugging (which will switch from JIT to the interpreter) and a DebuggingAgent interface, for use by v4 clients. Change-Id: I78e17a6cbe7196b0dfe4ee157fc028532131caa3 Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2013-07-24 08:29:04 +00:00
if (context->engine->debugger && (instr.breakPoint || context->engine->debugger->pauseAtNextOpportunity())) \
context->engine->debugger->maybeBreakAtInstruction(code, instr.breakPoint); \
Added property activation to the interpreter. Change-Id: Icbc900f8d617c8736a5663d19f5691f336bedb30 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-10-23 14:06:52 +00:00
Q_UNUSED(instr); \
TRACE_INSTR(I)
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#ifdef MOTH_THREADED_INTERPRETER
# define MOTH_BEGIN_INSTR(I) op_##I: \
MOTH_BEGIN_INSTR_COMMON(I)
# define MOTH_NEXT_INSTR(I) { \
genericInstr = reinterpret_cast<const Instr *>(code); \
goto *genericInstr->common.code; \
}
# define MOTH_END_INSTR(I) } \
genericInstr = reinterpret_cast<const Instr *>(code); \
goto *genericInstr->common.code; \
#else
# define MOTH_BEGIN_INSTR(I) \
case Instr::I: \
MOTH_BEGIN_INSTR_COMMON(I)
# define MOTH_NEXT_INSTR(I) { \
break; \
}
# define MOTH_END_INSTR(I) } \
break;
#endif
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
#ifdef WITH_STATS
namespace {
struct VMStats {
quint64 paramIsValue;
quint64 paramIsArg;
quint64 paramIsLocal;
quint64 paramIsTemp;
quint64 paramIsScopedLocal;
VMStats()
: paramIsValue(0)
, paramIsArg(0)
, paramIsLocal(0)
, paramIsTemp(0)
, paramIsScopedLocal(0)
{}
~VMStats()
{ show(); }
void show() {
fprintf(stderr, "VM stats:\n");
fprintf(stderr, " value: %lu\n", paramIsValue);
fprintf(stderr, " arg: %lu\n", paramIsArg);
fprintf(stderr, " local: %lu\n", paramIsLocal);
fprintf(stderr, " temp: %lu\n", paramIsTemp);
fprintf(stderr, " scoped local: %lu\n", paramIsScopedLocal);
}
};
static VMStats vmStats;
#define VMSTATS(what) ++vmStats.what
}
#else // !WITH_STATS
#define VMSTATS(what) {}
#endif // WITH_STATS
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
static inline QV4::Value *getValueRef(QV4::ExecutionContext *context,
QV4::Value* stack,
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
const Instr::Param &param
#if !defined(QT_NO_DEBUG)
, unsigned stackSize
#endif
)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
{
Remove the tempRegister from moth by loading/storing values directly. Change-Id: I51982d5852db2e10234620d63c235484c5b8a573 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-13 11:25:23 +00:00
#ifdef DO_TRACE_INSTR
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
if (param.isValue()) {
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
fprintf(stderr, " value %s\n", param.value.toString(context)->toQString().toUtf8().constData());
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
} else if (param.isArgument()) {
Implement fast argument lookups also for outter scopes Change-Id: If5b652a8ccfd81bdaa4d6f9ce83c0bf88daf18ae Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-21 19:50:55 +00:00
fprintf(stderr, " argument %d@%d\n", param.index, param.scope);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
} else if (param.isLocal()) {
fprintf(stderr, " local %d\n", param.index);
} else if (param.isTemp()) {
fprintf(stderr, " temp %d\n", param.index);
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
} else if (param.isScopedLocal()) {
fprintf(stderr, " temp %d@%d\n", param.index, param.scope);
Remove the tempRegister from moth by loading/storing values directly. Change-Id: I51982d5852db2e10234620d63c235484c5b8a573 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-13 11:25:23 +00:00
} else {
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
Q_ASSERT(!"INVALID");
Remove the tempRegister from moth by loading/storing values directly. Change-Id: I51982d5852db2e10234620d63c235484c5b8a573 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-13 11:25:23 +00:00
}
#endif // DO_TRACE_INSTR
Added property activation to the interpreter. Change-Id: Icbc900f8d617c8736a5663d19f5691f336bedb30 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-10-23 14:06:52 +00:00
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
if (param.isValue()) {
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
VMSTATS(paramIsValue);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
return const_cast<QV4::Value *>(&param.value);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
} else if (param.isArgument()) {
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
VMSTATS(paramIsArg);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::ExecutionContext *c = context;
Implement fast argument lookups also for outter scopes Change-Id: If5b652a8ccfd81bdaa4d6f9ce83c0bf88daf18ae Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-21 19:50:55 +00:00
uint scope = param.scope;
while (scope--)
c = c->outer;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::CallContext *cc = static_cast<QV4::CallContext *>(c);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
const unsigned arg = param.index;
Fix debug code and add some asserts. Change-Id: I947a72ff43190d15fd4a2857ed97b75cc510db66 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-20 09:08:14 +00:00
Q_ASSERT(arg >= 0);
Move arguments out of ExecutionContext and into CallContext Change-Id: Ic826e3e71eac9171fa113dec79db7c69982f2386 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-05 14:23:22 +00:00
Q_ASSERT((unsigned) arg < cc->argumentCount);
Q_ASSERT(cc->arguments);
return cc->arguments + arg;
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
} else if (param.isLocal()) {
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
VMSTATS(paramIsLocal);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
const unsigned index = param.index;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::CallContext *c = static_cast<QV4::CallContext *>(context);
Fix debug code and add some asserts. Change-Id: I947a72ff43190d15fd4a2857ed97b75cc510db66 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-20 09:08:14 +00:00
Q_ASSERT(index >= 0);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
Q_ASSERT(index < context->variableCount());
Move locals from ExecutionContext to CallContext Change-Id: I3f6751fc7e0450a74339f1131b10b56a2ebe6a50 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-05 12:16:56 +00:00
Q_ASSERT(c->locals);
return c->locals + index;
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
} else if (param.isTemp()) {
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
VMSTATS(paramIsTemp);
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
Q_ASSERT(param.index < stackSize);
return stack + param.index;
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
} else if (param.isScopedLocal()) {
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
VMSTATS(paramIsScopedLocal);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::ExecutionContext *c = context;
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
uint scope = param.scope;
while (scope--)
c = c->outer;
const unsigned index = param.index;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::CallContext *cc = static_cast<QV4::CallContext *>(c);
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
Q_ASSERT(index >= 0);
Move locals from ExecutionContext to CallContext Change-Id: I3f6751fc7e0450a74339f1131b10b56a2ebe6a50 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-05 12:16:56 +00:00
Q_ASSERT(index < cc->variableCount());
Q_ASSERT(cc->locals);
return cc->locals + index;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
} else {
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
Q_UNIMPLEMENTED();
return 0;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
}
}
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
#if defined(QT_NO_DEBUG)
Fix VALUE/VALUEPTR macros in the interpreter. Change-Id: I04f7625979974809bd62006520f67c5cb2d9c5fd Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com>
2013-06-03 11:32:51 +00:00
# define VALUE(param) (*VALUEPTR(param))
Inline the two most common parameter fetch cases. By inlining temp and local fetching, the interpreter is 30% faster on x86 on crypto.js. x86_64 gains about 35%. As the comment in the source already indicates: this might need some tweaking for QML. Change-Id: I9aa51036d42d2749f9aeec39a479d9e5f6233a23 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-11 11:00:13 +00:00
// The non-temp case might need some tweaking for QML: there it would probably be a value instead of a local.
# define VALUEPTR(param) \
Fix VALUE/VALUEPTR macros in the interpreter. Change-Id: I04f7625979974809bd62006520f67c5cb2d9c5fd Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com>
2013-06-03 11:32:51 +00:00
(param.isTemp() ? stack + param.index \
: (param.isLocal() ? static_cast<QV4::CallContext *>(context)->locals + param.index \
: getValueRef(context, stack, param)))
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
#else
# define VALUE(param) *getValueRef(context, stack, param, stackSize)
# define VALUEPTR(param) getValueRef(context, stack, param, stackSize)
#endif
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value VME::run(QV4::ExecutionContext *context, const uchar *&code,
QV4::Value *stack, unsigned stackSize
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#ifdef MOTH_THREADED_INTERPRETER
, void ***storeJumpTable
#endif
)
{
Split off 2 builtins into their own instruction. The foreach-iterator-object and foreach-next-property-name now have their own interpreter instructions. Also cleaned up the parameter passing helper methods. Change-Id: I3f375ba29e1ae914e707039b157fa011878b88b6 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 09:11:05 +00:00
#ifdef DO_TRACE_INSTR
qDebug("Starting VME with context=%p and code=%p", context, code);
#endif // DO_TRACE_INSTR
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#ifdef MOTH_THREADED_INTERPRETER
if (storeJumpTable) {
#define MOTH_INSTR_ADDR(I, FMT) &&op_##I,
static void *jumpTable[] = {
FOR_EACH_MOTH_INSTR(MOTH_INSTR_ADDR)
};
#undef MOTH_INSTR_ADDR
*storeJumpTable = jumpTable;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
return QV4::Value::undefinedValue();
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
}
#endif
Fix line number resolution with the interpreter and try {} catch {} When re-entering the interpreter for a try block, we use a different code pointer and therefore need to set context->interpreterInstructionPointer accordingly. We do that now at the beginning of run(), before we start interpreting the instructions. When returning from a try block, we continue using the old "code" pointer and therefore need to set context->interpreterInstructionPointer back. Change-Id: I607aef104d5f74bb0c44c6635619c99a6b397bce Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:20:08 +00:00
context->interpreterInstructionPointer = &code;
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#ifdef MOTH_THREADED_INTERPRETER
const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
goto *genericInstr->common.code;
#else
for (;;) {
const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
switch (genericInstr->common.instructionType) {
#endif
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(MoveTemp)
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
VALUE(instr.result) = VALUE(instr.source);
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(MoveTemp)
Merged Value load instructions. Change-Id: I45601d9618f8f569ff5705693fbea383d73c031d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-12-04 09:55:01 +00:00
MOTH_BEGIN_INSTR(LoadValue)
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
// TRACE(value, "%s", instr.value.toString(context)->toQString().toUtf8().constData());
VALUE(instr.result) = VALUE(instr.value);
Moved callBuiltin into the common super class. Now the backends do not need to duplicate the tedious switch, but can just implement the specific methods. It also prevents backends from missing out on cases. Change-Id: I45a25c6955af584f60b6e69cf6a616ca3e2dc640 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-16 14:49:42 +00:00
MOTH_END_INSTR(LoadValue)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(LoadClosure)
Ported closure init runtime functions to new calling convention Change-Id: Icb5765069b296977480d896aacfbd09d64dbdad6 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 15:18:01 +00:00
__qmljs_init_closure(context, VALUEPTR(instr.result), instr.value);
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(LoadClosure)
MOTH_BEGIN_INSTR(LoadName)
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
TRACE(inline, "property name = %s", instr.name->toQString().toUtf8().constData());
Change activition property calls to be pointer based After longer discussions, we actually found out that passing Values by reference (ie. as pointers) is most likely quite a bit more efficient then passing them by value. This is esp. true on 32bit platforms. So change the runtime back to a pointer based calling convention. Change-Id: I948d361b6876109d77fc58f11ceb47109cf631d1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 13:15:08 +00:00
__qmljs_get_activation_property(context, VALUEPTR(instr.result), instr.name);
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(LoadName)
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
MOTH_BEGIN_INSTR(StoreName)
TRACE(inline, "property name = %s", instr.name->toQString().toUtf8().constData());
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_set_activation_property(context, instr.name, VALUE(instr.source));
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
MOTH_END_INSTR(StoreName)
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_BEGIN_INSTR(LoadElement)
Adapt get/set_element to new calling convention Change-Id: I5e2bca8ee2435bf678dbf9eb15172ed59c80b52e Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-14 19:58:10 +00:00
__qmljs_get_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(LoadElement)
MOTH_BEGIN_INSTR(StoreElement)
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
__qmljs_set_element(context, VALUE(instr.base), VALUE(instr.index), VALUE(instr.source));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(StoreElement)
MOTH_BEGIN_INSTR(LoadProperty)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_get_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name);
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(LoadProperty)
MOTH_BEGIN_INSTR(StoreProperty)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_set_property(context, VALUE(instr.base), instr.name, VALUE(instr.source));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(StoreProperty)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Push)
Add tracing for runtime methods. Change-Id: I540297e83e3e297d0724c3e08e5780eee0d2fac8 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:31:02 +00:00
TRACE(inline, "stack size: %u", instr.value);
Add a MemoryManager, which does GC for the interpreter. Todo: - stack walking for MASM - fix all TODOs/FIXMEs and hidden treasures (bugs). Change-Id: I36f8cdc3a545df7287ce1df17b3570a9c017865e Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-04 12:40:18 +00:00
stackSize = instr.value;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
stack = static_cast<QV4::Value *>(alloca(stackSize * sizeof(QV4::Value)));
Add lifetime interval calculation. This is used in the interpreter to do stack-slot allocation. Change-Id: I9f4df8fdca35889f4b1154dbbe7d68b579886e18 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com>
2013-06-11 09:43:55 +00:00
memset(stack, 0, stackSize * sizeof(QV4::Value));
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(Push)
Implemented calls in the interpreter. Change-Id: Iafc9b04a1aa39272ab8aac24fb410a23df02a756 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 15:04:29 +00:00
MOTH_BEGIN_INSTR(CallValue)
Fix outgoing argument start position. Change-Id: Ie1b86746dc578ce479f5c072e2e1190826a7739c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-29 13:35:18 +00:00
#ifdef DO_TRACE_INSTR
if (Debugging::Debugger *debugger = context->engine->debugger) {
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
if (QV4::FunctionObject *o = (VALUE(instr.dest)).asFunctionObject()) {
Fix outgoing argument start position. Change-Id: Ie1b86746dc578ce479f5c072e2e1190826a7739c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-29 13:35:18 +00:00
if (Debugging::FunctionDebugInfo *info = debugger->debugInfo(o)) {
QString n = debugger->name(o);
std::cerr << "*** Call to \"" << (n.isNull() ? "<no name>" : qPrintable(n)) << "\" defined @" << info->startLine << ":" << info->startColumn << std::endl;
}
}
}
#endif // DO_TRACE_INSTR
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Converted calling runtime functions to new calling convention Change-Id: I03837e9b392957bd64a6710c1b85b4429556ba06 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 12:28:49 +00:00
__qmljs_call_value(context, VALUEPTR(instr.result), /*thisObject*/0, VALUE(instr.dest), args, instr.argc);
Implemented calls in the interpreter. Change-Id: Iafc9b04a1aa39272ab8aac24fb410a23df02a756 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 15:04:29 +00:00
MOTH_END_INSTR(CallValue)
MOTH_BEGIN_INSTR(CallProperty)
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
TRACE(property name, "%s, args=%u, argc=%u, this=%s", qPrintable(instr.name->toQString()), instr.args, instr.argc, (VALUE(instr.base)).toString(context)->toQString().toUtf8().constData());
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Converted calling runtime functions to new calling convention Change-Id: I03837e9b392957bd64a6710c1b85b4429556ba06 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 12:28:49 +00:00
__qmljs_call_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name, args, instr.argc);
Implemented calls in the interpreter. Change-Id: Iafc9b04a1aa39272ab8aac24fb410a23df02a756 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 15:04:29 +00:00
MOTH_END_INSTR(CallProperty)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
Fix call expressions with a subscript Call expressions such as foo[bar]() where wrongly converted to a temporary and then called by value. This made the call have the wrong this argument, as the reference was resolved in the assignment to the temporary. Change-Id: Id6044f833dfcf9ee8fa4f9ec0602a929abdc2c48 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 21:39:01 +00:00
MOTH_BEGIN_INSTR(CallElement)
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Converted calling runtime functions to new calling convention Change-Id: I03837e9b392957bd64a6710c1b85b4429556ba06 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 12:28:49 +00:00
__qmljs_call_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index), args, instr.argc);
reference locals in outer functions by index This makes V4 reference all variables in scopes that are not the global scope by index. The JIT and the interpreter walk up the scope chain to get the correct reference. Variables are only resolved by name for the global scope, if the scope contains an eval statement (as eval can define new variables) and inside with and catch scopes. Change-Id: Ib9f9d1a03d50124130aefd169eeb071533ba3520 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-15 12:36:49 +00:00
MOTH_END_INSTR(CallElement)
Fix call expressions with a subscript Call expressions such as foo[bar]() where wrongly converted to a temporary and then called by value. This made the call have the wrong this argument, as the reference was resolved in the assignment to the temporary. Change-Id: Id6044f833dfcf9ee8fa4f9ec0602a929abdc2c48 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 21:39:01 +00:00
Fix callBuiltinInvalid for the interpreter. Change-Id: Ifde12261a7c66a7b268129d5fae4ae626e16a00f Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 12:21:09 +00:00
MOTH_BEGIN_INSTR(CallActivationProperty)
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Add lifetime interval calculation. This is used in the interpreter to do stack-slot allocation. Change-Id: I9f4df8fdca35889f4b1154dbbe7d68b579886e18 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com>
2013-06-11 09:43:55 +00:00
TRACE(args, "starting at %d, length %d", instr.args, instr.argc);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Change activition property calls to be pointer based After longer discussions, we actually found out that passing Values by reference (ie. as pointers) is most likely quite a bit more efficient then passing them by value. This is esp. true on 32bit platforms. So change the runtime back to a pointer based calling convention. Change-Id: I948d361b6876109d77fc58f11ceb47109cf631d1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 13:15:08 +00:00
__qmljs_call_activation_property(context, VALUEPTR(instr.result), instr.name, args, instr.argc);
Fix callBuiltinInvalid for the interpreter. Change-Id: Ifde12261a7c66a7b268129d5fae4ae626e16a00f Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 12:21:09 +00:00
MOTH_END_INSTR(CallActivationProperty)
Split CallBuitin variants into separate instructions. This saves space by removing (sometimes) unused parameters, and the need to store and switch over another enum to determine which of the various built-in instructions is called. Change-Id: Ie59c49608bf445a07d406b45fd48cfb94bbfc919 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-27 08:59:37 +00:00
MOTH_BEGIN_INSTR(CallBuiltinThrow)
Fix file and line number reporting of QML/JS errors * Replace QUrl with QString in V4 for the source location (we don't need URL parsing) * Replace line number and file in QV4::Exception with the information we retrieve from the stack trace of the exception. Fixes about five tst_qqmlecmascript tests that relied on correct file/line number information Change-Id: I2a3daa72be6c5587fd965211ea8f6fb77142e7ee Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-05-27 12:19:35 +00:00
__qmljs_throw(context, VALUE(instr.arg));
Split CallBuitin variants into separate instructions. This saves space by removing (sometimes) unused parameters, and the need to store and switch over another enum to determine which of the various built-in instructions is called. Change-Id: Ie59c49608bf445a07d406b45fd48cfb94bbfc919 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-27 08:59:37 +00:00
MOTH_END_INSTR(CallBuiltinThrow)
Optimize exception throwing Introduce a try statement in the IR that allows the back-end to jump to the try and catch blocks directly instead of having a conditional jump for each entry. For the case where we have no catch but only try { ... } finally { ... } we create a synthetic catch block that sets hasException to true, to ensure that when an exception is thrown during try we execute finally and then rethrow the exception. Change-Id: If4be5421f9731522beab80e843283b517d4aa41c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:21 +00:00
MOTH_BEGIN_INSTR(EnterTry)
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
VALUE(instr.exceptionVar) = QV4::Value::undefinedValue();
Optimize exception throwing Introduce a try statement in the IR that allows the back-end to jump to the try and catch blocks directly instead of having a conditional jump for each entry. For the case where we have no catch but only try { ... } finally { ... } we create a synthetic catch block that sets hasException to true, to ensure that when an exception is thrown during try we execute finally and then rethrow the exception. Change-Id: If4be5421f9731522beab80e843283b517d4aa41c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:21 +00:00
try {
const uchar *tryCode = ((uchar *)&instr.tryOffset) + instr.tryOffset;
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
run(context, tryCode, stack, stackSize);
code = tryCode;
Fix line number resolution with the interpreter and try {} catch {} When re-entering the interpreter for a try block, we use a different code pointer and therefore need to set context->interpreterInstructionPointer accordingly. We do that now at the beginning of run(), before we start interpreting the instructions. When returning from a try block, we continue using the old "code" pointer and therefore need to set context->interpreterInstructionPointer back. Change-Id: I607aef104d5f74bb0c44c6635619c99a6b397bce Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:20:08 +00:00
context->interpreterInstructionPointer = &code;
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
} catch (QV4::Exception &ex) {
Cleanup: Get rid of manual unwind stack Instead of doing the ExecutionContext unwinding at the time of throw, do it at the time of catch, conveniently through an accept() method of the Exception object. That allows us to get rid of the separate handler registration stack. The only tricky part are that some execution contexts are allocated on the stack. When exceptions are thrown through that, we have to catch, unwinding up until that point (or rather the parent of the stack allocated context that's going to be deleted) and then simply rethrow. This patch also gets rid of the __builtin_delete_exception_handler. The next patch will rename the remainder to what it really does now. Change-Id: I00bb113b3a2fe24f7054c03fdfb8fed5cc1258b1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-04 11:12:21 +00:00
ex.accept(context);
Get rid of 'Value ExecutionEngine::exception' member Instead the JS exception value is now part of the C++ Exception object. This also allows getting rid of some run-time functions. Change-Id: I43ff773cacd5e925ba96601f3633ccf3b62273be Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:39 +00:00
VALUE(instr.exceptionVar) = ex.value();
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
try {
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::ExecutionContext *catchContext = __qmljs_builtin_push_catch_scope(instr.exceptionVarName, ex.value(), context);
Optimize exception throwing Introduce a try statement in the IR that allows the back-end to jump to the try and catch blocks directly instead of having a conditional jump for each entry. For the case where we have no catch but only try { ... } finally { ... } we create a synthetic catch block that sets hasException to true, to ensure that when an exception is thrown during try we execute finally and then rethrow the exception. Change-Id: If4be5421f9731522beab80e843283b517d4aa41c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:21 +00:00
const uchar *catchCode = ((uchar *)&instr.catchOffset) + instr.catchOffset;
Cleanup: Get rid of calls to builtin_{push,pop}_catch_scope in the IR These calls aren't needed anymore and can easily be done on the run-time level instead right before and after calling the catch block. Change-Id: I445361688782d12269764578e83ebb21ae184190 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:31 +00:00
run(catchContext, catchCode, stack, stackSize);
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
code = catchCode;
Fix line number resolution with the interpreter and try {} catch {} When re-entering the interpreter for a try block, we use a different code pointer and therefore need to set context->interpreterInstructionPointer accordingly. We do that now at the beginning of run(), before we start interpreting the instructions. When returning from a try block, we continue using the old "code" pointer and therefore need to set context->interpreterInstructionPointer back. Change-Id: I607aef104d5f74bb0c44c6635619c99a6b397bce Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:20:08 +00:00
context->interpreterInstructionPointer = &code;
Cleanup: Get rid of calls to builtin_{push,pop}_catch_scope in the IR These calls aren't needed anymore and can easily be done on the run-time level instead right before and after calling the catch block. Change-Id: I445361688782d12269764578e83ebb21ae184190 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:31 +00:00
context = __qmljs_builtin_pop_scope(catchContext);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
} catch (QV4::Exception &ex) {
Cleanup: Get rid of manual unwind stack Instead of doing the ExecutionContext unwinding at the time of throw, do it at the time of catch, conveniently through an accept() method of the Exception object. That allows us to get rid of the separate handler registration stack. The only tricky part are that some execution contexts are allocated on the stack. When exceptions are thrown through that, we have to catch, unwinding up until that point (or rather the parent of the stack allocated context that's going to be deleted) and then simply rethrow. This patch also gets rid of the __builtin_delete_exception_handler. The next patch will rename the remainder to what it really does now. Change-Id: I00bb113b3a2fe24f7054c03fdfb8fed5cc1258b1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-04 11:12:21 +00:00
ex.accept(context);
Get rid of 'Value ExecutionEngine::exception' member Instead the JS exception value is now part of the C++ Exception object. This also allows getting rid of some run-time functions. Change-Id: I43ff773cacd5e925ba96601f3633ccf3b62273be Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:39 +00:00
VALUE(instr.exceptionVar) = ex.value();
Optimize exception throwing Introduce a try statement in the IR that allows the back-end to jump to the try and catch blocks directly instead of having a conditional jump for each entry. For the case where we have no catch but only try { ... } finally { ... } we create a synthetic catch block that sets hasException to true, to ensure that when an exception is thrown during try we execute finally and then rethrow the exception. Change-Id: If4be5421f9731522beab80e843283b517d4aa41c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:21 +00:00
const uchar *catchCode = ((uchar *)&instr.catchOffset) + instr.catchOffset;
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
run(context, catchCode, stack, stackSize);
code = catchCode;
Fix line number resolution with the interpreter and try {} catch {} When re-entering the interpreter for a try block, we use a different code pointer and therefore need to set context->interpreterInstructionPointer accordingly. We do that now at the beginning of run(), before we start interpreting the instructions. When returning from a try block, we continue using the old "code" pointer and therefore need to set context->interpreterInstructionPointer back. Change-Id: I607aef104d5f74bb0c44c6635619c99a6b397bce Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:20:08 +00:00
context->interpreterInstructionPointer = &code;
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
}
}
Optimize exception throwing Introduce a try statement in the IR that allows the back-end to jump to the try and catch blocks directly instead of having a conditional jump for each entry. For the case where we have no catch but only try { ... } finally { ... } we create a synthetic catch block that sets hasException to true, to ensure that when an exception is thrown during try we execute finally and then rethrow the exception. Change-Id: If4be5421f9731522beab80e843283b517d4aa41c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-06 19:04:21 +00:00
MOTH_END_INSTR(EnterTry)
Split CallBuitin variants into separate instructions. This saves space by removing (sometimes) unused parameters, and the need to store and switch over another enum to determine which of the various built-in instructions is called. Change-Id: Ie59c49608bf445a07d406b45fd48cfb94bbfc919 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-27 08:59:37 +00:00
Cleanup: Rename __builtin_delete_exception_handler This IR builtin function no more deletes an exception handler, instead it tells the back-end to stop try catching exceptions. In MASM and Moth this is implemented by returning from the nested function call initiated by the try. Change-Id: Ia8336c998817a73aeed03f4a05d4b592cc9143ad Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-04 11:14:54 +00:00
MOTH_BEGIN_INSTR(CallBuiltinFinishTry)
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
return QV4::Value();
Cleanup: Rename __builtin_delete_exception_handler This IR builtin function no more deletes an exception handler, instead it tells the back-end to stop try catching exceptions. In MASM and Moth this is implemented by returning from the nested function call initiated by the try. Change-Id: Ia8336c998817a73aeed03f4a05d4b592cc9143ad Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-04 11:14:54 +00:00
MOTH_END_INSTR(CallBuiltinFinishTry)
Split CallBuitin variants into separate instructions. This saves space by removing (sometimes) unused parameters, and the need to store and switch over another enum to determine which of the various built-in instructions is called. Change-Id: Ie59c49608bf445a07d406b45fd48cfb94bbfc919 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-27 08:59:37 +00:00
MOTH_BEGIN_INSTR(CallBuiltinPushScope)
context = __qmljs_builtin_push_with_scope(VALUE(instr.arg), context);
MOTH_END_INSTR(CallBuiltinPushScope)
MOTH_BEGIN_INSTR(CallBuiltinPopScope)
context = __qmljs_builtin_pop_scope(context);
MOTH_END_INSTR(CallBuiltinPopScope)
Added calls to built-ins to moth. Change-Id: I277b1136ed3b073a9fc85726dc714ef68109fbfa Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-25 08:08:22 +00:00
Split off 2 builtins into their own instruction. The foreach-iterator-object and foreach-next-property-name now have their own interpreter instructions. Also cleaned up the parameter passing helper methods. Change-Id: I3f375ba29e1ae914e707039b157fa011878b88b6 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 09:11:05 +00:00
MOTH_BEGIN_INSTR(CallBuiltinForeachIteratorObject)
Port the remaining functions called from masm to pass-by-reference/pointer Change-Id: I1ea15fc500d0d2168aded2b6a2739420eb007b45 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-15 08:54:10 +00:00
__qmljs_foreach_iterator_object(context, VALUEPTR(instr.result), VALUE(instr.arg));
Split off 2 builtins into their own instruction. The foreach-iterator-object and foreach-next-property-name now have their own interpreter instructions. Also cleaned up the parameter passing helper methods. Change-Id: I3f375ba29e1ae914e707039b157fa011878b88b6 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 09:11:05 +00:00
MOTH_END_INSTR(CallBuiltinForeachIteratorObject)
MOTH_BEGIN_INSTR(CallBuiltinForeachNextPropertyName)
Port the remaining functions called from masm to pass-by-reference/pointer Change-Id: I1ea15fc500d0d2168aded2b6a2739420eb007b45 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-15 08:54:10 +00:00
__qmljs_foreach_next_property_name(VALUEPTR(instr.result), VALUE(instr.arg));
Split off 2 builtins into their own instruction. The foreach-iterator-object and foreach-next-property-name now have their own interpreter instructions. Also cleaned up the parameter passing helper methods. Change-Id: I3f375ba29e1ae914e707039b157fa011878b88b6 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-23 09:11:05 +00:00
MOTH_END_INSTR(CallBuiltinForeachNextPropertyName)
Added more builtins to moth. - delete member - delete subscript - delete name - delete value - foreach-iterator-object - foreach-next-property-name Change-Id: I639a3c3a293ea88019e2f69e1f51ce2264a68bcc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-12 13:31:05 +00:00
MOTH_BEGIN_INSTR(CallBuiltinDeleteMember)
Convert property deletion runtime functions to new calling convention Change-Id: I312ccbd65d9aad5e8db349af94c00bed0fd73544 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 15:02:40 +00:00
__qmljs_delete_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
Added more builtins to moth. - delete member - delete subscript - delete name - delete value - foreach-iterator-object - foreach-next-property-name Change-Id: I639a3c3a293ea88019e2f69e1f51ce2264a68bcc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-12 13:31:05 +00:00
MOTH_END_INSTR(CallBuiltinDeleteMember)
MOTH_BEGIN_INSTR(CallBuiltinDeleteSubscript)
Convert property deletion runtime functions to new calling convention Change-Id: I312ccbd65d9aad5e8db349af94c00bed0fd73544 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 15:02:40 +00:00
__qmljs_delete_subscript(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
Added more builtins to moth. - delete member - delete subscript - delete name - delete value - foreach-iterator-object - foreach-next-property-name Change-Id: I639a3c3a293ea88019e2f69e1f51ce2264a68bcc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-12 13:31:05 +00:00
MOTH_END_INSTR(CallBuiltinDeleteSubscript)
MOTH_BEGIN_INSTR(CallBuiltinDeleteName)
Convert property deletion runtime functions to new calling convention Change-Id: I312ccbd65d9aad5e8db349af94c00bed0fd73544 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 15:02:40 +00:00
__qmljs_delete_name(context, VALUEPTR(instr.result), instr.name);
Added more builtins to moth. - delete member - delete subscript - delete name - delete value - foreach-iterator-object - foreach-next-property-name Change-Id: I639a3c3a293ea88019e2f69e1f51ce2264a68bcc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-12 13:31:05 +00:00
MOTH_END_INSTR(CallBuiltinDeleteName)
Fix moth isel for typeof. Change-Id: If5b5a91a69d6b6bf0fd3eaf4c21a42c575839be2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-18 09:59:26 +00:00
MOTH_BEGIN_INSTR(CallBuiltinTypeofMember)
Convert builtin typeof to the new calling convention Change-Id: I40f268c53dacf2ee188b3d1df9391df3e5e812f8 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 11:16:30 +00:00
__qmljs_builtin_typeof_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
Fix moth isel for typeof. Change-Id: If5b5a91a69d6b6bf0fd3eaf4c21a42c575839be2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-18 09:59:26 +00:00
MOTH_END_INSTR(CallBuiltinTypeofMember)
MOTH_BEGIN_INSTR(CallBuiltinTypeofSubscript)
Convert builtin type of functions to new calling convention Change-Id: Ie0c9300eead2171c899bca54635e6fdf301385d3 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 11:56:05 +00:00
__qmljs_builtin_typeof_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
Fix moth isel for typeof. Change-Id: If5b5a91a69d6b6bf0fd3eaf4c21a42c575839be2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-18 09:59:26 +00:00
MOTH_END_INSTR(CallBuiltinTypeofSubscript)
MOTH_BEGIN_INSTR(CallBuiltinTypeofName)
Convert builtin type of functions to new calling convention Change-Id: Ie0c9300eead2171c899bca54635e6fdf301385d3 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 11:56:05 +00:00
__qmljs_builtin_typeof_name(context, VALUEPTR(instr.result), instr.name);
Fix moth isel for typeof. Change-Id: If5b5a91a69d6b6bf0fd3eaf4c21a42c575839be2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-18 09:59:26 +00:00
MOTH_END_INSTR(CallBuiltinTypeofName)
MOTH_BEGIN_INSTR(CallBuiltinTypeofValue)
Convert builtin type of functions to new calling convention Change-Id: Ie0c9300eead2171c899bca54635e6fdf301385d3 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 11:56:05 +00:00
__qmljs_builtin_typeof(context, VALUEPTR(instr.result), VALUE(instr.value));
Fix moth isel for typeof. Change-Id: If5b5a91a69d6b6bf0fd3eaf4c21a42c575839be2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-12-18 09:59:26 +00:00
MOTH_END_INSTR(CallBuiltinTypeofValue)
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_BEGIN_INSTR(CallBuiltinPostIncMember)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_builtin_post_increment_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofMember)
MOTH_BEGIN_INSTR(CallBuiltinPostIncSubscript)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_builtin_post_increment_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUEPTR(instr.index));
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofSubscript)
MOTH_BEGIN_INSTR(CallBuiltinPostIncName)
Convert post inc/dev operators to new calling convention Change-Id: Idbfa6852d308337076a1aa18cdeb43460fb5bed6 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 21:13:53 +00:00
__qmljs_builtin_post_increment_name(context, VALUEPTR(instr.result), instr.name);
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofName)
MOTH_BEGIN_INSTR(CallBuiltinPostIncValue)
Remove context argument for increment/decrement value Change-Id: I35c87190527a9eebd596aba8c4b100be77f552cd Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-15 07:46:45 +00:00
__qmljs_builtin_post_increment(VALUEPTR(instr.result), VALUEPTR(instr.value));
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofValue)
MOTH_BEGIN_INSTR(CallBuiltinPostDecMember)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_builtin_post_decrement_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofMember)
MOTH_BEGIN_INSTR(CallBuiltinPostDecSubscript)
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
__qmljs_builtin_post_decrement_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofSubscript)
MOTH_BEGIN_INSTR(CallBuiltinPostDecName)
Convert post inc/dev operators to new calling convention Change-Id: Idbfa6852d308337076a1aa18cdeb43460fb5bed6 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 21:13:53 +00:00
__qmljs_builtin_post_decrement_name(context, VALUEPTR(instr.result), instr.name);
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofName)
MOTH_BEGIN_INSTR(CallBuiltinPostDecValue)
Remove context argument for increment/decrement value Change-Id: I35c87190527a9eebd596aba8c4b100be77f552cd Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-15 07:46:45 +00:00
__qmljs_builtin_post_decrement(VALUEPTR(instr.result), VALUEPTR(instr.value));
Properly working post increment/decrement operators This required some larger changes in our infrastructure. Unfortunately the post increment/decrement operators don't return the old value unmodified, but return toNumber(oldValue). At the same time they need to properly store the new value into the referenced expression. The only way to solve this (as we can't have two return values) is to pass a proper reference into runtime methods. Change-Id: I0e0c2cc011ab22d5d4b27924abc8c18372c104a5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-01-27 20:16:09 +00:00
MOTH_END_INSTR(CallBuiltinTypeofValue)
Add more built-ins to the interpreter. Change-Id: I6a1656a8a2042b0a02d6e3bb8e59c9db52f6fd5d Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-27 11:17:19 +00:00
MOTH_BEGIN_INSTR(CallBuiltinDeclareVar)
__qmljs_builtin_declare_var(context, instr.isDeletable, instr.varName);
Moved callBuiltin into the common super class. Now the backends do not need to duplicate the tedious switch, but can just implement the specific methods. It also prevents backends from missing out on cases. Change-Id: I45a25c6955af584f60b6e69cf6a616ca3e2dc640 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-16 14:49:42 +00:00
MOTH_END_INSTR(CallBuiltinDeclareVar)
Add more built-ins to the interpreter. Change-Id: I6a1656a8a2042b0a02d6e3bb8e59c9db52f6fd5d Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-27 11:17:19 +00:00
moth: add builtin_define_getter_setter and builtin_define_property. Change-Id: Iffd8c79dbc99f9563235b440fa18e446cedabf0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-08 15:09:48 +00:00
MOTH_BEGIN_INSTR(CallBuiltinDefineGetterSetter)
Port the remaining functions called from masm to pass-by-reference/pointer Change-Id: I1ea15fc500d0d2168aded2b6a2739420eb007b45 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-15 08:54:10 +00:00
__qmljs_builtin_define_getter_setter(context, VALUE(instr.object), instr.name, VALUEPTR(instr.getter), VALUEPTR(instr.setter));
moth: add builtin_define_getter_setter and builtin_define_property. Change-Id: Iffd8c79dbc99f9563235b440fa18e446cedabf0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-08 15:09:48 +00:00
MOTH_END_INSTR(CallBuiltinDefineGetterSetter)
MOTH_BEGIN_INSTR(CallBuiltinDefineProperty)
Port the remaining functions called from masm to pass-by-reference/pointer Change-Id: I1ea15fc500d0d2168aded2b6a2739420eb007b45 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-15 08:54:10 +00:00
__qmljs_builtin_define_property(context, VALUE(instr.object), instr.name, VALUEPTR(instr.value));
moth: add builtin_define_getter_setter and builtin_define_property. Change-Id: Iffd8c79dbc99f9563235b440fa18e446cedabf0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-08 15:09:48 +00:00
MOTH_END_INSTR(CallBuiltinDefineProperty)
More efficient initialization of array literals Initialize array literals in one go instead of going through repeated calls to the runtime for each value. This gives quite a nice speed improvement on the splay tree benchmark. Change-Id: Id5757dd7a910be13db4958da7e449172ec1b04ae Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-01 15:47:07 +00:00
MOTH_BEGIN_INSTR(CallBuiltinDefineArray)
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
More efficient initialization of array literals Initialize array literals in one go instead of going through repeated calls to the runtime for each value. This gives quite a nice speed improvement on the splay tree benchmark. Change-Id: Id5757dd7a910be13db4958da7e449172ec1b04ae Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-01 15:47:07 +00:00
__qmljs_builtin_define_array(context, VALUEPTR(instr.result), args, instr.argc);
MOTH_END_INSTR(CallBuiltinDefineArray)
Fix properties of literal array initialisers Array entries defined in such a way need to be own properties. To avoid calling builtin_define_property with the integer index converted to a string for each property, this patch also introduces a builtin_define_array_property that takes an integer index instead. Change-Id: Ib21f99a555b3237753a7930a7edc70bfcd49ac18 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-24 11:53:47 +00:00
Speed up object literal construction Define the internal class at compile (isel) time, so that creation of the object at run-time is very fast. Change-Id: Ie153cda695cefde9d7118a7a65f1ff7e78f120cc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-04-23 05:31:02 +00:00
MOTH_BEGIN_INSTR(CallBuiltinDefineObjectLiteral)
QV4::Value *args = stack + instr.args;
Ported the compile-time class setup for object literals to be run-time based Change-Id: I21225e4bf0f66914229cf64fa29ce870548c0e93 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-16 11:21:31 +00:00
__qmljs_builtin_define_object_literal(context, VALUEPTR(instr.result), args, instr.internalClassId);
Speed up object literal construction Define the internal class at compile (isel) time, so that creation of the object at run-time is very fast. Change-Id: Ie153cda695cefde9d7118a7a65f1ff7e78f120cc Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-04-23 05:31:02 +00:00
MOTH_END_INSTR(CallBuiltinDefineObjectLiteral)
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_BEGIN_INSTR(CreateValue)
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Convert construct runtime functions to new calling convention Change-Id: I063508ff780d2f6371f77eca7138a09d78e1a45e Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 14:47:06 +00:00
__qmljs_construct_value(context, VALUEPTR(instr.result), VALUE(instr.func), args, instr.argc);
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(CreateValue)
MOTH_BEGIN_INSTR(CreateProperty)
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Convert construct runtime functions to new calling convention Change-Id: I063508ff780d2f6371f77eca7138a09d78e1a45e Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 14:47:06 +00:00
__qmljs_construct_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name, args, instr.argc);
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(CreateProperty)
MOTH_BEGIN_INSTR(CreateActivationProperty)
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
TRACE(inline, "property name = %s, args = %d, argc = %d", instr.name->toQString().toUtf8().constData(), instr.args, instr.argc);
Fix off-by-one in assertion for argc/args in calls. When a call is done with 1 argument, it is not copied into the outgoing args array, but passed by-reference. So when it happens to be the last element in the stack frame, then args + argc == stackSize (because argc is 1). Change-Id: Idb769c95e9066c24a9d93cdcc24e13d3a9acc995 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-03-04 08:32:16 +00:00
Q_ASSERT(instr.args + instr.argc <= stackSize);
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value *args = stack + instr.args;
Change activition property calls to be pointer based After longer discussions, we actually found out that passing Values by reference (ie. as pointers) is most likely quite a bit more efficient then passing them by value. This is esp. true on 32bit platforms. So change the runtime back to a pointer based calling convention. Change-Id: I948d361b6876109d77fc58f11ceb47109cf631d1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 13:15:08 +00:00
__qmljs_construct_activation_property(context, VALUEPTR(instr.result), instr.name, args, instr.argc);
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(CreateActivationProperty)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Jump)
Fix bug in jump logic Make the jump relative to the offset value in the instruction stream.
2012-06-12 17:26:29 +00:00
code = ((uchar *)&instr.offset) + instr.offset;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(Jump)
MOTH_BEGIN_INSTR(CJump)
cleanup __qmljs_to_boolean vs Value.toBoolean() Change-Id: Ic93eed2d4e68972d373bf1521387331ce26bac43 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-14 22:16:50 +00:00
uint cond = __qmljs_to_boolean(VALUE(instr.condition));
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
TRACE(condition, "%s", cond ? "TRUE" : "FALSE");
if (cond)
Fix bug in jump logic Make the jump relative to the offset value in the instruction stream.
2012-06-12 17:26:29 +00:00
code = ((uchar *)&instr.offset) + instr.offset;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(CJump)
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_BEGIN_INSTR(Unop)
Remove the context pointer from unary operations Change-Id: Idaf67f719402666e11676983d6bc99952f48a72d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-14 20:45:22 +00:00
instr.alu(VALUEPTR(instr.result), VALUE(instr.source));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(Unop)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Binop)
Remove context argument from most binops Change-Id: I4fa2636f1b2c8e8426b64d6e16bc7c223e6f327a Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-05 21:41:42 +00:00
instr.alu(VALUEPTR(instr.result), VALUE(instr.lhs), VALUE(instr.rhs));
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(Binop)
Remove context argument from most binops Change-Id: I4fa2636f1b2c8e8426b64d6e16bc7c223e6f327a Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-05 21:41:42 +00:00
MOTH_BEGIN_INSTR(BinopContext)
instr.alu(context, VALUEPTR(instr.result), VALUE(instr.lhs), VALUE(instr.rhs));
MOTH_END_INSTR(BinopContext)
Introducing SSA. Change-Id: Id3315f3560a8a7c996147eb070876b0065a23c76 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-05-02 13:40:35 +00:00
MOTH_BEGIN_INSTR(AddNumberParams)
Fix integer preserving arithmetics with the interpreter This fixes qqmllanguage and some other auto-tests with the interpreter When adding numbers, make sure to preserve them as integer if left and right hand side are integers. We do this now consistently throughout the runtime by providing fallback implementations of mul/sub/add_int32. Change-Id: I37e24ce14dc676bb072571b57289965ec59999c1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:55:45 +00:00
QV4::Value lhs = VALUE(instr.lhs);
QV4::Value rhs = VALUE(instr.rhs);
if (lhs.isInteger() && rhs.isInteger())
VALUE(instr.result) = QV4::add_int32(lhs.integerValue(), rhs.integerValue());
else
VALUEPTR(instr.result)->setDouble(lhs.asDouble() + rhs.asDouble());
Introducing SSA. Change-Id: Id3315f3560a8a7c996147eb070876b0065a23c76 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-05-02 13:40:35 +00:00
MOTH_END_INSTR(AddNumberParams)
MOTH_BEGIN_INSTR(MulNumberParams)
Fix integer preserving arithmetics with the interpreter This fixes qqmllanguage and some other auto-tests with the interpreter When adding numbers, make sure to preserve them as integer if left and right hand side are integers. We do this now consistently throughout the runtime by providing fallback implementations of mul/sub/add_int32. Change-Id: I37e24ce14dc676bb072571b57289965ec59999c1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:55:45 +00:00
QV4::Value lhs = VALUE(instr.lhs);
QV4::Value rhs = VALUE(instr.rhs);
if (lhs.isInteger() && rhs.isInteger())
VALUE(instr.result) = QV4::mul_int32(lhs.integerValue(), rhs.integerValue());
else
VALUEPTR(instr.result)->setDouble(lhs.asDouble() * rhs.asDouble());
Introducing SSA. Change-Id: Id3315f3560a8a7c996147eb070876b0065a23c76 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-05-02 13:40:35 +00:00
MOTH_END_INSTR(MulNumberParams)
MOTH_BEGIN_INSTR(SubNumberParams)
Fix integer preserving arithmetics with the interpreter This fixes qqmllanguage and some other auto-tests with the interpreter When adding numbers, make sure to preserve them as integer if left and right hand side are integers. We do this now consistently throughout the runtime by providing fallback implementations of mul/sub/add_int32. Change-Id: I37e24ce14dc676bb072571b57289965ec59999c1 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-05 13:55:45 +00:00
QV4::Value lhs = VALUE(instr.lhs);
QV4::Value rhs = VALUE(instr.rhs);
if (lhs.isInteger() && rhs.isInteger())
VALUE(instr.result) = QV4::sub_int32(lhs.integerValue(), rhs.integerValue());
else
VALUEPTR(instr.result)->setDouble(lhs.asDouble() - rhs.asDouble());
Introducing SSA. Change-Id: Id3315f3560a8a7c996147eb070876b0065a23c76 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-05-02 13:40:35 +00:00
MOTH_END_INSTR(SubNumberParams)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Ret)
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value &result = VALUE(instr.result);
Add utility function to print stack traces from lldb/gdb. Change-Id: I81315a1cd6900dbecfc9a39d9dc4256461163921 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-12-04 09:31:31 +00:00
// TRACE(Ret, "returning value %s", result.toString(context)->toQString().toUtf8().constData());
Fixed temp compression and added a whole lot of debug info. Unlike the variables (locals), the return value did not have a fixed temp. So by pinning it, it won't move around. Change-Id: Ib35024e2baa60b64fcb05ca4aa7f49acad89e7cb Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-22 15:28:13 +00:00
return result;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(Ret)
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
MOTH_BEGIN_INSTR(LoadThis)
Get rid of qmljs_get_this_object This is trivial to inline. Change-Id: Idccfc3c39d19e85768ec1be4b3b62b67abf00325 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-14 20:37:54 +00:00
VALUE(instr.result) = context->thisObject;
Added loading of "this" and renamed "ActivateProperty" to "StoreName". Change-Id: I033abe53368a815a9e3d036021429732f5526ea2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-24 11:45:43 +00:00
MOTH_END_INSTR(LoadThis)
Added property activation to the interpreter. Change-Id: Icbc900f8d617c8736a5663d19f5691f336bedb30 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2012-10-23 14:06:52 +00:00
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_BEGIN_INSTR(InplaceElementOp)
Convert inplace binops to pointer based calling convention Change-Id: Ie39fb9160573c79ea765466fc9750e2f50b52ab3 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 20:14:17 +00:00
instr.alu(context,
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
VALUE(instr.base),
VALUE(instr.index),
VALUE(instr.source));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(InplaceElementOp)
MOTH_BEGIN_INSTR(InplaceMemberOp)
Convert inplace binops to pointer based calling convention Change-Id: Ie39fb9160573c79ea765466fc9750e2f50b52ab3 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-02-13 20:14:17 +00:00
instr.alu(context,
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
VALUE(instr.base),
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
instr.member,
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
VALUE(instr.source));
Added more instruction selection to moth to get crypto.js through. Change-Id: Ic9582ea3241d97ef619304ece9f18c7eaae90407 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:54:20 +00:00
MOTH_END_INSTR(InplaceMemberOp)
Fixed/added name handling in expressions for moth. Change-Id: I6dc2faed00a465b74735d23e4c0bda9498dc7bd9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-07 15:31:10 +00:00
MOTH_BEGIN_INSTR(InplaceNameOp)
Change TEMP handling in the interpreter. By introducing the Param struct, and moving the ValueOrTemp into it too, the parameter decoding for instructions is cleaner and less error-prone: it de-couples the HIR/MIR representation from the interpreter representation, and allows for proper handling of the with-context. Change-Id: I0bc8f72bc7ce62b8efa298cbea5711adac4a4d34 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-25 18:32:30 +00:00
TRACE(name, "%s", instr.name->toQString().toUtf8().constData());
Convert run-time functions that take a Value * for arguments to use a Value reference This keeps the C++ implementation code simpler while still providing the same (pointer based) calling convention. Change-Id: Ib72acf1dfdf4638f6d109a0771fdafc921a544d2 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-02-14 09:45:49 +00:00
instr.alu(context, instr.name, VALUE(instr.source));
Fixed/added name handling in expressions for moth. Change-Id: I6dc2faed00a465b74735d23e4c0bda9498dc7bd9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-07 15:31:10 +00:00
MOTH_END_INSTR(InplaceNameOp)
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#ifdef MOTH_THREADED_INTERPRETER
// nothing to do
#else
default:
qFatal("QQmlJS::Moth::VME: Internal error - unknown instruction %d", genericInstr->common.instructionType);
break;
}
}
#endif
}
#ifdef MOTH_THREADED_INTERPRETER
void **VME::instructionJumpTable()
{
static void **jumpTable = 0;
if (!jumpTable) {
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
const uchar *code = 0;
VME().run(0, code, 0, 0, &jumpTable);
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
}
return jumpTable;
}
#endif
Rename QQmlJS::VM namespace to QV4 Simplifies writing code against it (less stuff to type). Change-Id: I8ac03ca2519375a204a3245e82c4be4cf1e793eb Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-04-19 11:03:42 +00:00
QV4::Value VME::exec(QV4::ExecutionContext *ctxt, const uchar *code)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
{
VME vme;
Implement JavaScript exceptions using C++ exceptions Instead of registering catch handlers with setjmp and throwing JS exceptions with longjmp, they are now thrown and caught as C++ exceptions. This allows for tight interoperability between C++ and JS in the future and allows for clear semantics with regards to cleaning up memory in the engine when throwing exceptions. (destructors are guaranteed to be called, unlike with setjmp/longjmp). The recent unwind table additions allow for the exceptions to be thrown through JIT generated code. Catching the exception is done by re-using the existing IR semantics where the beginning of a try block is marked by registering an exception handler. Execution after the registration continues conditionally, based on the return value of builtin_create_exception_handler. A return value of is 0 the try block(s) are executed. If an exception is thrown during that time, execution resumes at the point where builtin_create_exception_handler returns, but with a return value of 1. If an exception is thrown within the catch handler, the execution resumes again at the same point, but the inCatch IR variable will guide execution straight to the finally block(s), which calls delete_exception_handler. In the JIT as well as the interpreter this is implemented by entering a C++ code section that contains a C++ try {} catch {} block, in which the calling function is called again and continues right at the next instruction (or the interpreter loop is recursively entered). An exception will throw us out of that scope and back into the try {} catch {} wrapper, which can call again into the calling function. The IR guarantees that delete_exception_handler is always called, regardless of how the try or catch blocks are terminated. That is where in the JIT and interpreter we return from the nested function call and return back into the original stack frame, effectively unregistering the catch handler. Further cleanups with regards to the naming and the exception handler stack will come in subsequent patches, this is merely the minimal patch set to change to the new mechanism. This patch set breaks ARM until ARM exception handler tables are implemented. The interpreter changes are based on a patchset from Erik from https://codereview.qt-project.org/#change,45750 Change-Id: I543f2bd37b2186f7e48ffcab177d57b5ce932a0c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-03-01 16:04:21 +00:00
return vme.run(ctxt, code);
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
}