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

747 lines
30 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"
Rename some files Rename qv4value_def_p.h -> qv4value_p.h and qv4value_p.h to qv4value_inl_p.h. It makes more sense to have the class definition in the file that is named after the class and move the inline methods into a _inl file. Doing this now, as I expect we'll be needing a few more _inl files soon. Change-Id: Ib59e9380e9e976254c6b4369574157f39b1b5f51 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 14:07:34 +00:00
#include <private/qv4value_inl_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/qv4debugging_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>
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
#include <private/qv4scopedvalue_p.h>
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
#include <private/qv4lookup_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
Clean up our internal namespaces QQmlJS::MASM -> QV4::JIT QQmlJS::V4IR -> QV4::IR Change-Id: I707e8990459114a699c200fe3c22cec3c8df1afc Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-14 12:58:40 +00:00
using namespace QV4;
using namespace QV4::Moth;
Add tracing for runtime methods. Change-Id: I540297e83e3e297d0724c3e08e5780eee0d2fac8 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-11-06 11:31:02 +00:00
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; \
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_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_END_INSTR(I) } \
Fix interpreter without computed goto and new exception handling At the end of an instruction, don't break and run into the unreachable assert, instead use "continue" to get to the top of the for (;;) loop to resume execution. Change-Id: I544104e76cb7a547c050714da1c67cde6f11ba04 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-28 15:04:07 +00:00
continue;
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
#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
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
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
Param traceParam(const Param &param)
{
if (param.isConstant()) {
fprintf(stderr, " constant\n");
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
}
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
return Param
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
}
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))
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
# define VALUEPTR(param) (scopes[traceParam(param).scope] + param.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
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
# define VALUE(param) (*VALUEPTR(param))
# define VALUEPTR(param) (scopes[param.scope] + param.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
#endif
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
#define STOREVALUE(param, value) { \
QV4::ReturnedValue tmp = (value); \
Smaller performance fixes Move commonly used variables in the ExecutionEngine to the beginning of the struct to increase cache locality. Keep the engine pointer in a register in the interpreter to save one memory load per instruction. Change-Id: If2540c66b62685701511f410aff495c0a20ca694 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-05 15:12:16 +00:00
if (engine->hasException) \
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
goto catchException; \
VALUE(param) = tmp; \
}
#define CHECK_EXCEPTION \
Smaller performance fixes Move commonly used variables in the ExecutionEngine to the beginning of the struct to increase cache locality. Keep the engine pointer in a register in the interpreter to save one memory load per instruction. Change-Id: If2540c66b62685701511f410aff495c0a20ca694 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-05 15:12:16 +00:00
if (engine->hasException) \
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
goto catchException
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
Remove two unused parameters from VME::run() These parameters are not used outside the function itself anymore, so we can safely remove them. Change-Id: I1694481c05a9927fc78a59ffb7fec43a88e85ac8 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 12:22:36 +00:00
QV4::ReturnedValue VME::run(QV4::ExecutionContext *context, const uchar *code
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;
Move Value::fromBool, ... to a new Primitive class This will simplify finding the remaining direct usages of QV4::Value that need fixing. Change-Id: I223099727436d5748027c84c53d9dfc4028e38ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 10:24:36 +00:00
return QV4::Primitive::undefinedValue().asReturnedValue();
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
}
#endif
Remove two unused parameters from VME::run() These parameters are not used outside the function itself anymore, so we can safely remove them. Change-Id: I1694481c05a9927fc78a59ffb7fec43a88e85ac8 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 12:22:36 +00:00
QV4::Value *stack = 0;
unsigned stackSize = 0;
Debugging with V4 Currently missing, but coming in subsequent patches: - evaluating expressions - evaluating breakpoint conditions Change-Id: Ib43f2a3aaa252741ea7ce857a274480feb8741aa Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-16 10:29:47 +00:00
const uchar *exceptionHandler = 0;
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
context->d()->lineNumber = -1;
QV4::ExecutionEngine *engine = context->d()->engine;
Debugging with V4 Currently missing, but coming in subsequent patches: - evaluating expressions - evaluating breakpoint conditions Change-Id: Ib43f2a3aaa252741ea7ce857a274480feb8741aa Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-16 10:29:47 +00:00
#ifdef DO_TRACE_INSTR
qDebug("Starting VME with context=%p and code=%p", context, code);
#endif // DO_TRACE_INSTR
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::StringValue * const runtimeStrings = context->d()->compilationUnit->runtimeStrings;
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
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
// setup lookup scopes
int scopeDepth = 0;
{
QV4::ExecutionContext *scope = context;
while (scope) {
++scopeDepth;
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
scope = scope->d()->outer;
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
}
}
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
QV4::Value **scopes = static_cast<QV4::Value **>(alloca(sizeof(QV4::Value *)*(2 + 2*scopeDepth)));
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
{
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
scopes[0] = const_cast<QV4::Value *>(context->d()->compilationUnit->data->constants());
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
// stack gets setup in push instruction
scopes[1] = 0;
QV4::ExecutionContext *scope = context;
int i = 0;
while (scope) {
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
if (scope->d()->type >= QV4::ExecutionContext::Type_SimpleCallContext) {
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
QV4::CallContext *cc = static_cast<QV4::CallContext *>(scope);
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
scopes[2*i + 2] = cc->d()->callData->args;
Convert Execution contexts to new constructor syntax Change-Id: I4bc6a61b7a96139353e20871ff7ff007822c64c3 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-09 14:50:17 +00:00
scopes[2*i + 3] = cc->d()->locals;
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
} else {
scopes[2*i + 2] = 0;
scopes[2*i + 3] = 0;
}
++i;
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
scope = scope->d()->outer;
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
}
}
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
for (;;) {
const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
#ifdef MOTH_THREADED_INTERPRETER
goto *genericInstr->common.code;
#else
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
switch (genericInstr->common.instructionType) {
#endif
Remove the LoadValue instruction With the constant table this is exactly the same as a move. Also renamed MoveTemp to Move, as it not only moves Temps but also other variables. Change-Id: I1fccc04314661954179d903519adbc39777395e5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 07:17:54 +00:00
MOTH_BEGIN_INSTR(Move)
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);
Remove the LoadValue instruction With the constant table this is exactly the same as a move. Also renamed MoveTemp to Move, as it not only moves Temps but also other variables. Change-Id: I1fccc04314661954179d903519adbc39777395e5 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 07:17:54 +00:00
MOTH_END_INSTR(Move)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
Add a MoveConst instruction to the interpreter This simplifies and speeds up loading of constants Change-Id: I05b4f7a34abd4ed6416fa800a31debbb28b37104 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 12:19:27 +00:00
MOTH_BEGIN_INSTR(MoveConst)
VALUE(instr.result) = instr.source;
MOTH_END_INSTR(MoveConst)
V4: Fix SSA decomposition when no regalloc is used. Add scheduling for moves generated by removing phi nodes by re-using the MoveMapping class from the register allocator. This change applies to both the JIT when no register allocator is used, and the interpreter. Change-Id: I38eac5b13759c7790132d1ef07fa17fcb53187e3 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-01 13:45:53 +00:00
MOTH_BEGIN_INSTR(SwapTemps)
qSwap(VALUE(instr.left), VALUE(instr.right));
MOTH_END_INSTR(MoveTemp)
Prospective MSVC build fix It seems LoadString is somehow expanded as a macro, so call the instruction LoadRuntimeString, which is closer to the meaning. Change-Id: I16836b495d29db8cb1af5874762c8e66acb9c529 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-19 09:57:03 +00:00
MOTH_BEGIN_INSTR(LoadRuntimeString)
Ported identifiers in moth to use runtime strings Change-Id: I09f04994a2ebe631b12fa76b77a622711de31926 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-16 14:35:05 +00:00
// TRACE(value, "%s", instr.value.toString(context)->toQString().toUtf8().constData());
Remove more direct QV4::Value usage Remove Value::fromString(String *), and make Encode safe against encoding raw Managed * pointers. Change-Id: Ibca4668e1cbeaf85c78169d14386281659d33ef6 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 13:24:50 +00:00
VALUE(instr.result) = runtimeStrings[instr.stringId].asReturnedValue();
Prospective MSVC build fix It seems LoadString is somehow expanded as a macro, so call the instruction LoadRuntimeString, which is closer to the meaning. Change-Id: I16836b495d29db8cb1af5874762c8e66acb9c529 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-19 09:57:03 +00:00
MOTH_END_INSTR(LoadRuntimeString)
Ported identifiers in moth to use runtime strings Change-Id: I09f04994a2ebe631b12fa76b77a622711de31926 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-16 14:35:05 +00:00
Get rid of QV4::Function::generatedValues by porting moths' regexps to runtime expressions Change-Id: Iaae3c4855016948952159596d2528fca73341b72 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-16 14:40:21 +00:00
MOTH_BEGIN_INSTR(LoadRegExp)
// TRACE(value, "%s", instr.value.toString(context)->toQString().toUtf8().constData());
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
VALUE(instr.result) = context->d()->compilationUnit->runtimeRegularExpressions[instr.regExpId];
Get rid of QV4::Function::generatedValues by porting moths' regexps to runtime expressions Change-Id: Iaae3c4855016948952159596d2528fca73341b72 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-08-16 14:40:21 +00:00
MOTH_END_INSTR(LoadRegExp)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(LoadClosure)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::closure(context, instr.value));
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(LoadClosure)
MOTH_BEGIN_INSTR(LoadName)
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
TRACE(inline, "property name = %s", runtimeStrings[instr.name]->toQString().toUtf8().constData());
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::getActivationProperty(context, runtimeStrings[instr.name]));
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(LoadName)
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(GetGlobalLookup)
TRACE(inline, "property name = %s", runtimeStrings[instr.name]->toQString().toUtf8().constData());
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Lookup *l = context->d()->lookups + instr.index;
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
STOREVALUE(instr.result, l->globalGetter(l, context));
MOTH_END_INSTR(GetGlobalLookup)
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)
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
TRACE(inline, "property name = %s", runtimeStrings[instr.name]->toQString().toUtf8().constData());
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::setActivationProperty(context, runtimeStrings[instr.name], VALUEPTR(instr.source));
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
CHECK_EXCEPTION;
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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::getElement(context, VALUEPTR(instr.base), VALUEPTR(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)
Use lookups for get/setElement in the interpreter Significantly speeds up crypto.js Change-Id: Icd3d59bea3fe4427e93e9e10e3526178e8de859c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-31 13:58:14 +00:00
MOTH_BEGIN_INSTR(LoadElementLookup)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Lookup *l = context->d()->lookups + instr.lookup;
Use lookups for get/setElement in the interpreter Significantly speeds up crypto.js Change-Id: Icd3d59bea3fe4427e93e9e10e3526178e8de859c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-31 13:58:14 +00:00
STOREVALUE(instr.result, l->indexedGetter(l, VALUEPTR(instr.base), VALUEPTR(instr.index)));
MOTH_END_INSTR(LoadElementLookup)
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(StoreElement)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::setElement(context, VALUEPTR(instr.base), VALUEPTR(instr.index), VALUEPTR(instr.source));
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
CHECK_EXCEPTION;
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)
Use lookups for get/setElement in the interpreter Significantly speeds up crypto.js Change-Id: Icd3d59bea3fe4427e93e9e10e3526178e8de859c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-31 13:58:14 +00:00
MOTH_BEGIN_INSTR(StoreElementLookup)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Lookup *l = context->d()->lookups + instr.lookup;
Use lookups for get/setElement in the interpreter Significantly speeds up crypto.js Change-Id: Icd3d59bea3fe4427e93e9e10e3526178e8de859c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-31 13:58:14 +00:00
l->indexedSetter(l, VALUEPTR(instr.base), VALUEPTR(instr.index), VALUEPTR(instr.source));
CHECK_EXCEPTION;
MOTH_END_INSTR(StoreElementLookup)
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(LoadProperty)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::getProperty(context, VALUEPTR(instr.base), runtimeStrings[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)
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(GetLookup)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Lookup *l = context->d()->lookups + instr.index;
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
STOREVALUE(instr.result, l->getter(l, VALUEPTR(instr.base)));
MOTH_END_INSTR(GetLookup)
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(StoreProperty)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::setProperty(context, VALUEPTR(instr.base), runtimeStrings[instr.name], VALUEPTR(instr.source));
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
CHECK_EXCEPTION;
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)
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(SetLookup)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Lookup *l = context->d()->lookups + instr.index;
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
l->setter(l, VALUEPTR(instr.base), VALUEPTR(instr.source));
CHECK_EXCEPTION;
MOTH_END_INSTR(SetLookup)
Implement setting of values to resolved QObject properties After the resolution of a property, we can set it by index at run-time instead of via name resolution. Change-Id: I479599dabe343cf9e6582dcda12291aebfcce418 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-28 14:18:31 +00:00
MOTH_BEGIN_INSTR(StoreQObjectProperty)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::setQmlQObjectProperty(context, VALUEPTR(instr.base), instr.propertyIndex, VALUEPTR(instr.source));
Implement setting of values to resolved QObject properties After the resolution of a property, we can set it by index at run-time instead of via name resolution. Change-Id: I479599dabe343cf9e6582dcda12291aebfcce418 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-28 14:18:31 +00:00
CHECK_EXCEPTION;
MOTH_END_INSTR(StoreQObjectProperty)
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
MOTH_BEGIN_INSTR(LoadQObjectProperty)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::getQmlQObjectProperty(context, VALUEPTR(instr.base), instr.propertyIndex, instr.captureRequired));
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
MOTH_END_INSTR(LoadQObjectProperty)
Add support for accelerated property access to QML types and namespace support * Resolve lookups in namespaces at compile time and instruct the SSA optimizer to eliminate reads from the namespace (QQmlTypeWrapper) if possible. For example access to attached properties of types (i.e. MyNameSpace.ListView.isCurrentItem) requires neither reading the namespace nor the type. * Add support for accelerated lookup of attached properties Change-Id: Ib0b66404ed7e70e1d4a46a1ac8218743a4cc8608 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-14 23:06:18 +00:00
MOTH_BEGIN_INSTR(LoadAttachedQObjectProperty)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::getQmlAttachedProperty(context, instr.attachedPropertiesId, instr.propertyIndex));
Add support for accelerated property access to QML types and namespace support * Resolve lookups in namespaces at compile time and instruct the SSA optimizer to eliminate reads from the namespace (QQmlTypeWrapper) if possible. For example access to attached properties of types (i.e. MyNameSpace.ListView.isCurrentItem) requires neither reading the namespace nor the type. * Add support for accelerated lookup of attached properties Change-Id: Ib0b66404ed7e70e1d4a46a1ac8218743a4cc8608 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-14 23:06:18 +00:00
MOTH_END_INSTR(LoadAttachedQObjectProperty)
Accelerate property lookups for C++-based QObject singletons. Change-Id: Icbdf06a077014db5dd57cba42f84591433ec4196 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-07-23 17:43:38 +00:00
MOTH_BEGIN_INSTR(LoadSingletonQObjectProperty)
STOREVALUE(instr.result, Runtime::getQmlSingletonQObjectProperty(context, VALUEPTR(instr.base), instr.propertyIndex, instr.captureRequired));
MOTH_END_INSTR(LoadSingletonQObjectProperty)
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;
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
stack = context->engine()->stackPush(stackSize);
Remove a memset that is not required Keep it in debug builds to ease debugging. Change-Id: I334872d3c0ef30b5f09fb5febfc2129a3b450bca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 13:57:09 +00:00
#ifndef QT_NO_DEBUG
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
memset(stack, 0, stackSize * sizeof(QV4::Value));
Remove a memset that is not required Keep it in debug builds to ease debugging. Change-Id: I334872d3c0ef30b5f09fb5febfc2129a3b450bca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 13:57:09 +00:00
#endif
Rework parameter handling for moth Get rid of the parameter type, and only store a scope, that is an index into a SafeValue ** array. This significantly speeds up loading and saving of parameters. Change-Id: I185145f1afd0b8cea461c7ca732ada3ebe39c34c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 09:28:04 +00:00
scopes[1] = stack;
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)
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
#if 0 //def DO_TRACE_INSTR
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
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
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
Move Value::fromBool, ... to a new Primitive class This will simplify finding the remaining direct usages of QV4::Value that need fixing. Change-Id: I223099727436d5748027c84c53d9dfc4028e38ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 10:24:36 +00:00
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callValue(context, VALUEPTR(instr.dest), callData));
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)
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
TRACE(property name, "%s, args=%u, argc=%u, this=%s", qPrintable(runtimeStrings[instr.name]->toQString()), instr.callData, instr.argc, (VALUE(instr.base)).toString(context)->toQString().toUtf8().constData());
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
callData->thisObject = VALUE(instr.base);
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callProperty(context, runtimeStrings[instr.name], callData));
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
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(CallPropertyLookup)
TRACE(property name, "%s, args=%u, argc=%u, this=%s", qPrintable(runtimeStrings[instr.name]->toQString()), instr.callData, instr.argc, (VALUE(instr.base)).toString(context)->toQString().toUtf8().constData());
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
callData->tag = QV4::Value::Integer_Type;
callData->argc = instr.argc;
callData->thisObject = VALUE(instr.base);
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callPropertyLookup(context, instr.lookupIndex, callData));
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_END_INSTR(CallPropertyLookup)
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)
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
callData->thisObject = VALUE(instr.base);
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callElement(context, VALUEPTR(instr.index), callData));
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)
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);
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
Move Value::fromBool, ... to a new Primitive class This will simplify finding the remaining direct usages of QV4::Value that need fixing. Change-Id: I223099727436d5748027c84c53d9dfc4028e38ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 10:24:36 +00:00
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callActivationProperty(context, runtimeStrings[instr.name], callData));
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)
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(CallGlobalLookup)
TRACE(args, "starting at %d, length %d", instr.args, instr.argc);
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
callData->tag = QV4::Value::Integer_Type;
callData->argc = instr.argc;
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::callGlobalLookup(context, instr.index, callData));
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_END_INSTR(CallGlobalLookup)
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
MOTH_BEGIN_INSTR(SetExceptionHandler)
exceptionHandler = instr.offset ? ((uchar *)&instr.offset) + instr.offset : 0;
MOTH_END_INSTR(SetExceptionHandler)
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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::throwException(context, VALUEPTR(instr.arg));
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
CHECK_EXCEPTION;
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)
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
MOTH_BEGIN_INSTR(CallBuiltinUnwindException)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::unwindException(context));
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
MOTH_END_INSTR(CallBuiltinUnwindException)
MOTH_BEGIN_INSTR(CallBuiltinPushCatchScope)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
context = Runtime::pushCatchScope(context, runtimeStrings[instr.name]);
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
MOTH_END_INSTR(CallBuiltinPushCatchScope)
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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
context = Runtime::pushWithScope(VALUEPTR(instr.arg), context);
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(CallBuiltinPushScope)
MOTH_BEGIN_INSTR(CallBuiltinPopScope)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
context = Runtime::popScope(context);
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(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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::foreachIterator(context, VALUEPTR(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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::foreachNextPropertyName(VALUEPTR(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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::deleteMember(context, VALUEPTR(instr.base), runtimeStrings[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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::deleteElement(context, VALUEPTR(instr.base), VALUEPTR(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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::deleteName(context, runtimeStrings[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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::typeofMember(context, VALUEPTR(instr.base), runtimeStrings[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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::typeofElement(context, VALUEPTR(instr.base), VALUEPTR(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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::typeofName(context, runtimeStrings[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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::typeofValue(context, VALUEPTR(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)
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)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::declareVar(context, instr.isDeletable, runtimeStrings[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
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);
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
QV4::Value *args = stack + instr.args;
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::arrayLiteral(context, args, instr.argc));
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_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)
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
QV4::Value *args = stack + instr.args;
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::objectLiteral(context, args, instr.internalClassId, instr.arrayValueCount, instr.arrayGetterSetterCountAndFlags));
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)
Move arguments object creation into the generated code So far we've been creating the arguments object at runtime in initCallContext(). It's much more efficient to simply add arguments as a local variable in qv4codegen if it's being used and initialize it through a builtin method. Change-Id: I6913f3565adf3aa1917adae8dceef9f50ecf1722 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-16 10:54:30 +00:00
MOTH_BEGIN_INSTR(CallBuiltinSetupArgumentsObject)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::setupArgumentsObject(context));
Move arguments object creation into the generated code So far we've been creating the arguments object at runtime in initCallContext(). It's much more efficient to simply add arguments as a local variable in qv4codegen if it's being used and initialize it through a builtin method. Change-Id: I6913f3565adf3aa1917adae8dceef9f50ecf1722 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-08-16 10:54:30 +00:00
MOTH_END_INSTR(CallBuiltinSetupArgumentsObject)
Move conversion of this object into generated code When a non strict mode function uses the this object, we need to make sure it's being correctly converted into a object before being accessed. So far this was being done by ScriptFunction::call. Move this into the generated code to avoid overhead for methods not using 'this', and simplify our ScriptFunction::call() implementation. Change-Id: I739f4a89d29ed8082ce59e48d1523776224fc29d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-02 20:10:13 +00:00
MOTH_BEGIN_INSTR(CallBuiltinConvertThisToObject)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
Runtime::convertThisToObject(context);
Move conversion of this object into generated code When a non strict mode function uses the this object, we need to make sure it's being correctly converted into a object before being accessed. So far this was being done by ScriptFunction::call. Move this into the generated code to avoid overhead for methods not using 'this', and simplify our ScriptFunction::call() implementation. Change-Id: I739f4a89d29ed8082ce59e48d1523776224fc29d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-02 20:10:13 +00:00
CHECK_EXCEPTION;
MOTH_END_INSTR(CallBuiltinConvertThisToObject)
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)
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
Move Value::fromBool, ... to a new Primitive class This will simplify finding the remaining direct usages of QV4::Value that need fixing. Change-Id: I223099727436d5748027c84c53d9dfc4028e38ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 10:24:36 +00:00
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::constructValue(context, VALUEPTR(instr.func), callData));
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)
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
Use lookups for create_property (ie. new foo.bar) This is not used that often, but it removes one more place where we do lookups by name. Change-Id: I9f798b8b4a64be3fdf3e53090e4288724c9d2b22 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-13 10:45:51 +00:00
callData->thisObject = VALUE(instr.base);
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::constructProperty(context, runtimeStrings[instr.name], callData));
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)
Use lookups for create_property (ie. new foo.bar) This is not used that often, but it removes one more place where we do lookups by name. Change-Id: I9f798b8b4a64be3fdf3e53090e4288724c9d2b22 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-13 10:45:51 +00:00
MOTH_BEGIN_INSTR(ConstructPropertyLookup)
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Use lookups for create_property (ie. new foo.bar) This is not used that often, but it removes one more place where we do lookups by name. Change-Id: I9f798b8b4a64be3fdf3e53090e4288724c9d2b22 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-13 10:45:51 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
callData->tag = QV4::Value::Integer_Type;
callData->argc = instr.argc;
callData->thisObject = VALUE(instr.base);
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::constructPropertyLookup(context, instr.index, callData));
Use lookups for create_property (ie. new foo.bar) This is not used that often, but it removes one more place where we do lookups by name. Change-Id: I9f798b8b4a64be3fdf3e53090e4288724c9d2b22 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-11-13 10:45:51 +00:00
MOTH_END_INSTR(ConstructPropertyLookup)
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(CreateActivationProperty)
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
TRACE(inline, "property name = %s, args = %d, argc = %d", runtimeStrings[instr.name]->toQString().toUtf8().constData(), instr.args, instr.argc);
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
Refactor our NaN boxing to be more efficient * Use a unified way to store all Managed objects inside a Value, instead of distinguishing between strings and other objects. * On 64 bit we store pointers as pointers, so accessing them through Scoped<> objects is cheap. This implies that doubles are now stored in a mangled form (xor'ed with a mask). Change-Id: I582e0fb167a62c0c527c6bfa3452550e37944069 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-15 13:46:36 +00:00
callData->tag = QV4::Value::Integer_Type;
Generate CallData structures directly in the instruction selection Like this we can hand the CallData through the runtime methods without any need to modify them. This simplifies the code in there, and should also speed them up to some degree. Change-Id: Ibd92ff4a8f279a5c4a054c5678646f658cfed5ca Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-05 12:49:55 +00:00
callData->argc = instr.argc;
Move Value::fromBool, ... to a new Primitive class This will simplify finding the remaining direct usages of QV4::Value that need fixing. Change-Id: I223099727436d5748027c84c53d9dfc4028e38ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-25 10:24:36 +00:00
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::constructActivationProperty(context, runtimeStrings[instr.name], callData));
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)
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_BEGIN_INSTR(ConstructGlobalLookup)
TRACE(inline, "property name = %s, args = %d, argc = %d", runtimeStrings[instr.name]->toQString().toUtf8().constData(), instr.args, instr.argc);
Cleanups Remove SafeValue, it was used to port over to an exact GC. Since we now have that, we can now safely merge it with QV4::Value again. Also rename SafeString to StringValue for better naming consistency. Change-Id: I8553d1bec5134c53996f6b0d758738a0ec8a2e4d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-01-24 21:55:39 +00:00
Q_ASSERT(instr.callData + instr.argc + qOffsetOf(QV4::CallData, args)/sizeof(QV4::Value) <= stackSize);
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
QV4::CallData *callData = reinterpret_cast<QV4::CallData *>(stack + instr.callData);
callData->tag = QV4::Value::Integer_Type;
callData->argc = instr.argc;
callData->thisObject = QV4::Primitive::undefinedValue();
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::constructGlobalLookup(context, instr.index, callData));
Use lookups in the interpreter Implement lookup calls for the interpreter. This significantly reduces overhead by avoiding repeated name lookups on the same object type. This doubles the speed of quite a few of the v8 benchmarks, and brings the interpreter up to close to 40% of the speed of the JIT. Change-Id: Ie8c2f5b1ca71a7329bc643c3d2158a6301a392ed Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-10 09:51:42 +00:00
MOTH_END_INSTR(ConstructGlobalLookup)
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)
Specialize CJump into JumpEq and JumpNe This avoids the bool invert in the instruction stream, and some additional code in the VME. Change-Id: I0ea675a2e3d07c1b8c5234b888d8d9683bcee330 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 14:05:35 +00:00
MOTH_BEGIN_INSTR(JumpEq)
bool cond = VALUEPTR(instr.condition)->toBoolean();
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;
Specialize CJump into JumpEq and JumpNe This avoids the bool invert in the instruction stream, and some additional code in the VME. Change-Id: I0ea675a2e3d07c1b8c5234b888d8d9683bcee330 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 14:05:35 +00:00
MOTH_END_INSTR(JumpEq)
MOTH_BEGIN_INSTR(JumpNe)
bool cond = VALUEPTR(instr.condition)->toBoolean();
TRACE(condition, "%s", cond ? "TRUE" : "FALSE");
if (!cond)
code = ((uchar *)&instr.offset) + instr.offset;
MOTH_END_INSTR(JumpNe)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_BEGIN_INSTR(UNot)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::uNot(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(UNot)
Optimize some unops and binops for moth Optimize unops for ints/bools and add some special binops where one side is constant. Change-Id: I4f5639e36458560e5614371733abaafd94909ab1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 15:06:43 +00:00
MOTH_BEGIN_INSTR(UNotBool)
bool b = VALUE(instr.source).booleanValue();
VALUE(instr.result) = QV4::Encode(!b);
MOTH_END_INSTR(UNotBool)
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_BEGIN_INSTR(UPlus)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::uPlus(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(UPlus)
MOTH_BEGIN_INSTR(UMinus)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::uMinus(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(UMinus)
MOTH_BEGIN_INSTR(UCompl)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::complement(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(UCompl)
Optimize some unops and binops for moth Optimize unops for ints/bools and add some special binops where one side is constant. Change-Id: I4f5639e36458560e5614371733abaafd94909ab1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 15:06:43 +00:00
MOTH_BEGIN_INSTR(UComplInt)
VALUE(instr.result) = QV4::Encode((int)~VALUE(instr.source).integerValue());
MOTH_END_INSTR(UComplInt)
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_BEGIN_INSTR(Increment)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::increment(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(Increment)
MOTH_BEGIN_INSTR(Decrement)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::decrement(VALUEPTR(instr.source)));
Inline unary operations in moth Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 11:53:05 +00:00
MOTH_END_INSTR(Decrement)
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
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Binop)
Convert ReturnedValue into a primitive (typedef to quint64) ReturnedValue is used to return values from runtime methods The type has to be a primitive type (no struct or union), so that the compiler will return it in a register on all platforms. They will be returned in rax on x64, [eax,edx] on x86 and [r0,r1] on arm. Change-Id: I38433e6fad252370dda5dc335d9c5be8f22e8c76 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-11 09:28:27 +00:00
STOREVALUE(instr.result, instr.alu(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_END_INSTR(Binop)
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_BEGIN_INSTR(Add)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::add(context, VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(Add)
MOTH_BEGIN_INSTR(BitAnd)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::bitAnd(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(BitAnd)
MOTH_BEGIN_INSTR(BitOr)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::bitOr(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(BitOr)
MOTH_BEGIN_INSTR(BitXor)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::bitXor(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(BitXor)
Add specialized instructions for right and left shift These give a measurable speedup as the critical code paths are now inline. Change-Id: I3cee8a432fbe96d66ba1e6bd277a38e624a50c14 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 13:56:32 +00:00
MOTH_BEGIN_INSTR(Shr)
STOREVALUE(instr.result, QV4::Encode((int)(VALUEPTR(instr.lhs)->toInt32() >> (VALUEPTR(instr.rhs)->toInt32() & 0x1f))));
MOTH_END_INSTR(Shr)
MOTH_BEGIN_INSTR(Shl)
STOREVALUE(instr.result, QV4::Encode((int)(VALUEPTR(instr.lhs)->toInt32() << (VALUEPTR(instr.rhs)->toInt32() & 0x1f))));
MOTH_END_INSTR(Shl)
Optimize some unops and binops for moth Optimize unops for ints/bools and add some special binops where one side is constant. Change-Id: I4f5639e36458560e5614371733abaafd94909ab1 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 15:06:43 +00:00
MOTH_BEGIN_INSTR(BitAndConst)
int lhs = VALUEPTR(instr.lhs)->toInt32();
STOREVALUE(instr.result, QV4::Encode((int)(lhs & instr.rhs)));
MOTH_END_INSTR(BitAnd)
MOTH_BEGIN_INSTR(BitOrConst)
int lhs = VALUEPTR(instr.lhs)->toInt32();
STOREVALUE(instr.result, QV4::Encode((int)(lhs | instr.rhs)));
MOTH_END_INSTR(BitOr)
MOTH_BEGIN_INSTR(BitXorConst)
int lhs = VALUEPTR(instr.lhs)->toInt32();
STOREVALUE(instr.result, QV4::Encode((int)(lhs ^ instr.rhs)));
MOTH_END_INSTR(BitXor)
Add specialized instructions for right and left shift These give a measurable speedup as the critical code paths are now inline. Change-Id: I3cee8a432fbe96d66ba1e6bd277a38e624a50c14 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 13:56:32 +00:00
MOTH_BEGIN_INSTR(ShrConst)
STOREVALUE(instr.result, QV4::Encode((int)(VALUEPTR(instr.lhs)->toInt32() >> instr.rhs)));
MOTH_END_INSTR(ShrConst)
MOTH_BEGIN_INSTR(ShlConst)
STOREVALUE(instr.result, QV4::Encode((int)(VALUEPTR(instr.lhs)->toInt32() << instr.rhs)));
MOTH_END_INSTR(ShlConst)
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_BEGIN_INSTR(Mul)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::mul(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(Mul)
MOTH_BEGIN_INSTR(Sub)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
STOREVALUE(instr.result, Runtime::sub(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
Moth: Inline a couple of binops This gives another 10-15% for v8-bench Change-Id: Iaea90402179813af23008c35d344fa7f5353cf5f Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-29 14:28:17 +00:00
MOTH_END_INSTR(Sub)
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)
Convert ReturnedValue into a primitive (typedef to quint64) ReturnedValue is used to return values from runtime methods The type has to be a primitive type (no struct or union), so that the compiler will return it in a register on all platforms. They will be returned in rax on x64, [eax,edx] on x86 and [r0,r1] on arm. Change-Id: I38433e6fad252370dda5dc335d9c5be8f22e8c76 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-11 09:28:27 +00:00
STOREVALUE(instr.result, instr.alu(context, VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));
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_END_INSTR(BinopContext)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
MOTH_BEGIN_INSTR(Ret)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
context->engine()->stackPop(stackSize);
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());
remove more uses of QV4::Value Change-Id: I11b0b2b7626297e2c98dc77784574da4b59ba8cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-09-27 14:15:38 +00:00
return VALUE(instr.result).asReturnedValue();
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
Add a special Debug instruction to the interpreter and use it This avoid having to check for the debugger at every instruction we execute. Instead we only add debug instructions at the beginning of every line and every basic block when we have a debugger. This still allows interrupting the JS execution at any time (as we can't loop inside a basic block), and single stepping through lines. But it has no overhead when the debugger is not running and a lot less when it is running. Change-Id: Ib17170b42944b608fc6caa1891082205dd2b2763 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-02-05 13:38:03 +00:00
MOTH_BEGIN_INSTR(Debug)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
context->d()->lineNumber = instr.lineNumber;
QV4::Debugging::Debugger *debugger = context->engine()->debugger;
Simplify our breakpoint handling Only store a Hash of break points in the debugger, instead of the involved logic that currently adds and removes break points. Add the current line number to the Debug statements in the interpreter, and pass them on to the debugger for checking whether we should really break. This adds a slight additional overhead to running inside the debugger, but greatly simplifies the logic and doesn't require modifying the bytecode anymore. This in turn opens up the possibility to run the debugger on JIT generated code later on. Change-Id: If2a3ae8f8d08b69a3a704cbbe0a84000f917a32e Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-03 13:20:54 +00:00
if (debugger && debugger->pauseAtNextOpportunity())
Add a Line instruction to the interpreter This unifies the way we handle line numbers in the JIT and Interpreter. Remove the now unused lineNumberMapping code and data. Change-Id: I1d60b1fbb77e70b531fa73d93410683e84dd1e3c Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-03 13:41:31 +00:00
debugger->maybeBreakAtInstruction();
MOTH_END_INSTR(Debug)
MOTH_BEGIN_INSTR(Line)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
context->d()->lineNumber = instr.lineNumber;
Add a special Debug instruction to the interpreter and use it This avoid having to check for the debugger at every instruction we execute. Instead we only add debug instructions at the beginning of every line and every basic block when we have a debugger. This still allows interrupting the JS execution at any time (as we can't loop inside a basic block), and single stepping through lines. But it has no overhead when the debugger is not running and a lot less when it is running. Change-Id: Ib17170b42944b608fc6caa1891082205dd2b2763 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-02-05 13:38:03 +00:00
MOTH_END_INSTR(Debug)
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)
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
VALUE(instr.result) = context->d()->callData->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
IR Cleanup, resolve ID objects through array subscripts ...instead of a special MEMBER type. This allows removing the type member from V4IR::Member altogether (and thus unshadow from V4IR::Expr::type). By not requiring the base of a id lookup member expression to be a NAME, we can also speed up repeated id lookups by fetching the id object array wrapper only once per function. Change-Id: I3e9b8f498d32ace4a0cc2254f49e02ecc124f79c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-02 17:48:18 +00:00
MOTH_BEGIN_INSTR(LoadQmlIdArray)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
VALUE(instr.result) = Runtime::getQmlIdArray(static_cast<QV4::NoThrowContext*>(context));
IR Cleanup, resolve ID objects through array subscripts ...instead of a special MEMBER type. This allows removing the type member from V4IR::Member altogether (and thus unshadow from V4IR::Expr::type). By not requiring the base of a id lookup member expression to be a NAME, we can also speed up repeated id lookups by fetching the id object array wrapper only once per function. Change-Id: I3e9b8f498d32ace4a0cc2254f49e02ecc124f79c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-02 17:48:18 +00:00
MOTH_END_INSTR(LoadQmlIdArray)
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
Speed up lookups of imported scripts The QQmlContextData stores the JS objects of imported scripts in a QList<PersistentValue>. Instead of indexing into that list, this patch changes ctxt->importedScripts to be a JavaScript array, that in the IR we can index via subscript. Change-Id: Ie2c35fb5294a20a0b7084bb51d19671a27195fec Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-29 10:59:54 +00:00
MOTH_BEGIN_INSTR(LoadQmlImportedScripts)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
VALUE(instr.result) = Runtime::getQmlImportedScripts(static_cast<QV4::NoThrowContext*>(context));
Speed up lookups of imported scripts The QQmlContextData stores the JS objects of imported scripts in a QList<PersistentValue>. Instead of indexing into that list, this patch changes ctxt->importedScripts to be a JavaScript array, that in the IR we can index via subscript. Change-Id: Ie2c35fb5294a20a0b7084bb51d19671a27195fec Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-29 10:59:54 +00:00
MOTH_END_INSTR(LoadQmlImportedScripts)
Implement loading of resolved imported scripts We can resolve the use of names that refer to imported scripts at compile time and load them at run-time by index through context->importedScripts. Change-Id: I681b19e7d68dbf3b9a68af00b4cea2a9254c2d78 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-28 16:02:54 +00:00
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
MOTH_BEGIN_INSTR(LoadQmlContextObject)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
VALUE(instr.result) = Runtime::getQmlContextObject(static_cast<QV4::NoThrowContext*>(context));
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
MOTH_END_INSTR(LoadContextObject)
MOTH_BEGIN_INSTR(LoadQmlScopeObject)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
VALUE(instr.result) = Runtime::getQmlScopeObject(static_cast<QV4::NoThrowContext*>(context));
Initial support for resolving meta-property access for the scope and context objects at QML compile time This avoids having to do a string lookup for ids and in the import cache at run-time, before we can do a string hash lookup in the property cache. Instead we resolve final properties in the context and scope object at compile time and look them up at run-time using their index instead. The dependencies to these properties are also tracked separately and recorded in the compiled data. This is merely the initial patch. There's a lot left to do, such as having specialized getter and setters for specific property types. Setters are missing altogether right now and will fall back to name lookup. Change-Id: If3cb4e7c9454ef4850a615f0935b311c9395b165 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-24 12:51:02 +00:00
MOTH_END_INSTR(LoadScopeObject)
Speed up id object lookups We can resolve lookups for objects referenced by id at QML compile time and use a run-time helper to extract the id object out of the QML context data by index instead of name. Dependencies to id objects are also tracked at compile time and registered separately before entering the generated function code. The lookup of id objects is encoded in the IR as special member lookups. Members will also then in the future be used to for property lookups in context and scope properties, as well as any other property lookups in QObjects where we can determine the meta-object. Change-Id: I36cf3ceb11b51a983da6cad5b61c3bf574acc20a Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-10-23 14:24:58 +00:00
Initial support for accelerated property access to QML singletons and enums With this patch we determine the meta-object of singletons, propagate it into the IR and load them separately using a dedicated run-time function. In addition enums in singletons and QML types are resolved at compile time. Change-Id: I01ce1288391b476d1c9af669cb2987a44c885703 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-02 21:46:25 +00:00
MOTH_BEGIN_INSTR(LoadQmlSingleton)
Cleanup our runtime methods Move all our runtime methods into the QV4::Runtime struct and give them nicer names without underscores. Sort them logically and remove a few unused methods. Change-Id: Ib69b71764ff194d0ba211aac581f9a99734d8180 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-10 18:58:05 +00:00
VALUE(instr.result) = Runtime::getQmlSingleton(static_cast<QV4::NoThrowContext*>(context), runtimeStrings[instr.name]);
Initial support for accelerated property access to QML singletons and enums With this patch we determine the meta-object of singletons, propagate it into the IR and load them separately using a dedicated run-time function. In addition enums in singletons and QML types are resolved at compile time. Change-Id: I01ce1288391b476d1c9af669cb2987a44c885703 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-02 21:46:25 +00:00
MOTH_END_INSTR(LoadQmlSingleton)
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
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
Q_ASSERT(false);
catchException:
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
Q_ASSERT(context->engine()->hasException);
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
if (!exceptionHandler) {
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
context->engine()->stackPop(stackSize);
Implement new exception handling for moth Add the required instructions and check for exceptions in the engine before storing any results. Change-Id: Ibfaf904d659859e8012920270825211ba202c63d Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-23 12:03:09 +00:00
return QV4::Encode::undefined();
}
code = exceptionHandler;
}
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
}
#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;
Remove two unused parameters from VME::run() These parameters are not used outside the function itself anymore, so we can safely remove them. Change-Id: I1694481c05a9927fc78a59ffb7fec43a88e85ac8 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-02-06 12:22:36 +00:00
VME().run(0, code, &jumpTable);
Add skeleton moth vme
2012-06-11 16:58:52 +00:00
}
return jumpTable;
}
#endif
Change calling convention in JIT to use ReturnedValue This simplifies the masm backend as well and should be faster. Change-Id: I64ad5d9ee1b6caca950471e3aec4ef19d7503e62 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-09-11 10:46:20 +00:00
QV4::ReturnedValue VME::exec(QV4::ExecutionContext *ctxt, const uchar *code)
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
{
VME vme;
Convert ExecutionContext to new storage scheme Change-Id: I9fcc13da5360f37cef3149b114ed9263b9b74281 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-05-06 07:23:59 +00:00
QV4::Debugging::Debugger *debugger = ctxt->engine()->debugger;
Debugging with V4 Currently missing, but coming in subsequent patches: - evaluating expressions - evaluating breakpoint conditions Change-Id: Ib43f2a3aaa252741ea7ce857a274480feb8741aa Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2013-10-16 10:29:47 +00:00
if (debugger)
debugger->enteringFunction();
QV4::ReturnedValue retVal = vme.run(ctxt, code);
if (debugger)
debugger->leavingFunction(retVal);
return retVal;
Begin to implement moth vm
2012-06-12 17:13:55 +00:00
}