qv4vme_moth.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
 
#include "qv4vme_moth_p.h"
 
#include <QtCore/qjsondocument.h>
#include <QtCore/qjsonobject.h>
 
#include <private/qv4alloca_p.h>
#include <private/qv4instr_moth_p.h>
#include <private/qv4value_p.h>
#include <private/qv4debugging_p.h>
#include <private/qv4function_p.h>
#include <private/qv4functionobject_p.h>
#include <private/qv4math_p.h>
#include <private/qv4scopedvalue_p.h>
#include <private/qv4lookup_p.h>
#include <private/qv4regexp_p.h>
#include <private/qv4regexpobject_p.h>
#include <private/qv4string_p.h>
#include <private/qv4profiling_p.h>
#include <private/qv4jscall_p.h>
#include <private/qv4generatorobject_p.h>
#include <private/qv4alloca_p.h>
#include <private/qqmljavascriptexpression_p.h>
#include <private/qv4qmlcontext_p.h>
#include <QtQml/private/qv4runtime_p.h>
#include <iostream>
 
#if QT_CONFIG(qml_jit)
#include <private/qv4baselinejit_p.h>
#endif
 
#include <qtqml_tracepoints_p.h>
 
#undef COUNT_INSTRUCTIONS
 
Q_TRACE_POINT(qtqml, QQmlV4_function_call_entry, const QV4::ExecutionEngine *engine, const QString &function, const QString &fileName, int line, int column)
Q_TRACE_POINT(qtqml, QQmlV4_function_call_exit)
 
enum { ShowWhenDeoptimiationHappens = 0 };
 
extern "C" {
 
// This is the interface to Qt Creator's (new) QML debugger.
 
/*! \internal
    \since 5.5
 
    This function is called uncondionally from VME::run().
 
    An attached debugger can set a breakpoint here to
    intercept calls to VME::run().
 */
 
Q_QML_EXPORT void qt_v4ResolvePendingBreakpointsHook()
{
}
 
/*! \internal
    \since 5.5
 
    This function is called when a QML interpreter breakpoint
    is hit.
 
    An attached debugger can set a breakpoint here.
*/
Q_QML_EXPORT void qt_v4TriggeredBreakpointHook()
{
}
 
/*! \internal
    \since 5.5
 
    The main entry point into "Native Mixed" Debugging.
 
    Commands are passed as UTF-8 encoded JSON data.
    The data has two compulsory fields:
    \list
    \li \c version: Version of the protocol (currently 1)
    \li \c command: Name of the command
    \endlist
 
    Depending on \c command, more fields can be present.
 
    Error is indicated by negative return values,
    success by non-negative return values.
 
    \c protocolVersion:
    Returns version of implemented protocol.
 
    \c insertBreakpoint:
    Sets a breakpoint on a given file and line.
    \list
    \li \c fullName: Name of the QML/JS file
    \li \c lineNumber: Line number in the file
    \li \c condition: Breakpoint condition
    \endlist
    Returns a unique positive number as handle.
 
    \c removeBreakpoint:
    Removes a breakpoint from a given file and line.
    \list
    \li \c fullName: Name of the QML/JS file
    \li \c lineNumber: Line number in the file
    \li \c condition: Breakpoint condition
    \endlist
    Returns zero on success, a negative number on failure.
 
    \c prepareStep:
    Puts the interpreter in stepping mode.
    Returns zero.
 
*/
Q_QML_EXPORT int qt_v4DebuggerHook(const char *json);
 
 
} // extern "C"
 
#if QT_CONFIG(qml_debug)
static int qt_v4BreakpointCount = 0;
static bool qt_v4IsDebugging = false;
static bool qt_v4IsStepping = false;
 
namespace {
class Breakpoint
{
public:
    Breakpoint() : bpNumber(0), lineNumber(-1) {}
 
    bool matches(const QString &file, int line) const
    {
        return fullName == file && lineNumber == line;
    }
 
    int bpNumber;
    int lineNumber;
    QString fullName;      // e.g. /opt/project/main.qml
    QString engineName;    // e.g. qrc:/main.qml
    QString condition;     // optional
};
 
QList<Breakpoint> qt_v4Breakpoints;
Breakpoint qt_v4LastStop;
 
void qt_v4TriggerBreakpoint(const Breakpoint &bp, QV4::Function *function)
{
    qt_v4LastStop = bp;
 
    // Set up some auxiliary data for informational purpose.
    // This is not part of the protocol.
    QV4::Heap::String *functionName = function->name();
    QByteArray functionNameUtf8;
    if (functionName)
        functionNameUtf8 = functionName->toQString().toUtf8();
 
    qt_v4TriggeredBreakpointHook(); // Trigger Breakpoint.
}
 
}
 
int qt_v4DebuggerHook(const char *json)
{
    const int ProtocolVersion = 1;
 
    enum {
        Success = 0,
        WrongProtocol,
        NoSuchCommand,
        NoSuchBreakpoint
    };
 
    QJsonDocument doc = QJsonDocument::fromJson(json);
    QJsonObject ob = doc.object();
    QByteArray command = ob.value(QLatin1String("command")).toString().toUtf8();
 
    if (command == "protocolVersion") {
        return ProtocolVersion; // Version number.
    }
 
    int version = ob.value(QLatin1String("version")).toString().toInt();
    if (version != ProtocolVersion) {
        return -WrongProtocol;
    }
 
    if (command == "insertBreakpoint") {
        Breakpoint bp;
        bp.bpNumber = ++qt_v4BreakpointCount;
        bp.lineNumber = ob.value(QLatin1String("lineNumber")).toString().toInt();
        bp.engineName = ob.value(QLatin1String("engineName")).toString();
        bp.fullName = ob.value(QLatin1String("fullName")).toString();
        bp.condition = ob.value(QLatin1String("condition")).toString();
        qt_v4Breakpoints.append(bp);
        qt_v4IsDebugging = true;
        return bp.bpNumber;
    }
 
    if (command == "removeBreakpoint") {
        int lineNumber = ob.value(QLatin1String("lineNumber")).toString().toInt();
        QString fullName = ob.value(QLatin1String("fullName")).toString();
        if (qt_v4Breakpoints.last().matches(fullName, lineNumber)) {
            qt_v4Breakpoints.removeLast();
            qt_v4IsDebugging = !qt_v4Breakpoints.isEmpty();
            return Success;
        }
        for (int i = 0; i + 1 < qt_v4Breakpoints.size(); ++i) {
            if (qt_v4Breakpoints.at(i).matches(fullName, lineNumber)) {
                qt_v4Breakpoints[i] = qt_v4Breakpoints.takeLast();
                return Success; // Ok.
            }
        }
        return -NoSuchBreakpoint; // Failure
    }
 
    if (command == "prepareStep") {
        qt_v4IsStepping = true;
        return Success; // Ok.
    }
 
 
    return -NoSuchCommand; // Failure.
}
 
Q_NEVER_INLINE static void qt_v4CheckForBreak(QV4::CppStackFrame *frame)
{
    if (!qt_v4IsStepping && !qt_v4Breakpoints.size())
        return;
 
    const int lineNumber = frame->lineNumber();
    QV4::Function *function = frame->v4Function;
    QString engineName = function->sourceFile();
 
    if (engineName.isEmpty())
        return;
 
    if (qt_v4IsStepping) {
        if (qt_v4LastStop.lineNumber != lineNumber
                || qt_v4LastStop.engineName != engineName) {
            qt_v4IsStepping = false;
            Breakpoint bp;
            bp.bpNumber = 0;
            bp.lineNumber = lineNumber;
            bp.engineName = engineName;
            qt_v4TriggerBreakpoint(bp, function);
            return;
        }
    }
 
    for (int i = qt_v4Breakpoints.size(); --i >= 0; ) {
        const Breakpoint &bp = qt_v4Breakpoints.at(i);
        if (bp.lineNumber != lineNumber)
            continue;
        if (bp.engineName != engineName)
            continue;
 
        qt_v4TriggerBreakpoint(bp, function);
    }
}
 
Q_NEVER_INLINE static void debug_slowPath(QV4::ExecutionEngine *engine)
{
    QV4::Debugging::Debugger *debugger = engine->debugger();
    if (debugger && debugger->pauseAtNextOpportunity())
        debugger->maybeBreakAtInstruction();
    if (qt_v4IsDebugging)
        qt_v4CheckForBreak(engine->currentStackFrame);
}
 
#endif // QT_CONFIG(qml_debug)
// End of debugger interface
 
using namespace QV4;
using namespace QV4::Moth;
 
#ifdef COUNT_INSTRUCTIONS
static struct InstrCount {
    InstrCount() {
        fprintf(stderr, "Counting instructions...\n");
        for (int i = 0; i < MOTH_NUM_INSTRUCTIONS(); ++i)
            hits[i] = 0;
    }
    ~InstrCount() {
        fprintf(stderr, "Instruction count:\n");
#define BLAH(I)
        fprintf(stderr, "%llu : %s\n", hits[int(Instr::Type::I)], #I);
        FOR_EACH_MOTH_INSTR(BLAH)
        #undef BLAH
    }
    quint64 hits[MOTH_NUM_INSTRUCTIONS()];
    void hit(Instr::Type i) { hits[int(i)]++; }
} instrCount;
#endif // COUNT_INSTRUCTIONS
 
#define MOTH_BEGIN_INSTR_COMMON(instr)
    {
        INSTR_##instr(MOTH_DECODE)
 
#ifdef COUNT_INSTRUCTIONS
#  define MOTH_BEGIN_INSTR(instr)
    MOTH_BEGIN_INSTR_COMMON(instr)
    instrCount.hit(Instr::Type::instr);
#else // !COUNT_INSTRUCTIONS
#  define MOTH_BEGIN_INSTR(instr)
    MOTH_BEGIN_INSTR_COMMON(instr)
#endif // COUNT_INSTRUCTIONS
 
#ifdef MOTH_COMPUTED_GOTO
#define MOTH_END_INSTR(instr)
        MOTH_DISPATCH_SINGLE()
    }
#else // !MOTH_COMPUTED_GOTO
#define MOTH_END_INSTR(instr)
        continue;
    }
#endif
 
static inline QV4::Value &stackValue(QV4::Value *stack, size_t slot, const JSTypesStackFrame *frame)
{
    Q_ASSERT(slot < CallData::HeaderSize() / sizeof(QV4::StaticValue)
                    + frame->jsFrame->argc()
                    + frame->v4Function->compiledFunction->nRegisters);
    Q_UNUSED(frame);
 
    return stack[slot];
}
 
#define STACK_VALUE(temp) stackValue(stack, temp, frame)
 
// qv4scopedvalue_p.h also defines a CHECK_EXCEPTION macro
#ifdef CHECK_EXCEPTION
#undef CHECK_EXCEPTION
#endif
#define CHECK_EXCEPTION
    if (engine->hasException || engine->isInterrupted.loadRelaxed())
        goto handleUnwind
 
static inline Heap::CallContext *getScope(QV4::Value *stack, int level)
{
    Heap::ExecutionContext *scope = static_cast<ExecutionContext &>(stack[CallData::Context]).d();
    while (level > 0) {
        --level;
        scope = scope->outer;
    }
    Q_ASSERT(scope);
    return static_cast<Heap::CallContext *>(scope);
}
 
static inline const QV4::Value &constant(Function *function, int index)
{
    return function->compilationUnit->constants[index].asValue<QV4::Value>();
}
 
static bool compareEqualInt(QV4::Value &accumulator, QV4::Value lhs, int rhs)
{
  redo:
    if (lhs.isUndefined())
        return false;
    if (lhs.isManagedOrUndefined()) {
        // LHS: Managed
        if (lhs.m()->internalClass->vtable->isString)
            return RuntimeHelpers::stringToNumber(static_cast<String &>(lhs).toQString()) == rhs;
        accumulator = lhs;
        lhs = QV4::Value::fromReturnedValue(RuntimeHelpers::objectDefaultValue(&static_cast<QV4::Object &>(accumulator), PREFERREDTYPE_HINT));
        goto redo;
    }
 
    switch (lhs.quickType()) {
    case QV4::Value::QT_Empty:
        Q_UNREACHABLE();
    case QV4::Value::QT_Null:
        return false;
    case QV4::Value::QT_Bool:
    case QV4::Value::QT_Int:
        return lhs.int_32() == rhs;
    default: // double
        return lhs.doubleValue() == rhs;
    }
}
 
#define STORE_IP() frame->instructionPointer = int(code - function->codeData);
#define STORE_ACC() accumulator = acc;
#define ACC Value::fromReturnedValue(acc)
#define VALUE_TO_INT(i, val)
    int i;
    do {
        if (Q_LIKELY(val.integerCompatible())) {
            i = val.int_32();
        } else {
            double d;
            if (val.isDouble())
                d = val.doubleValue();
            else {
                STORE_ACC();
                d = val.toNumberImpl();
                CHECK_EXCEPTION;
            }
            i = QJSNumberCoercion::toInteger(d);
        }
    } while (false)
 
namespace {
struct AOTCompiledMetaMethod
{
public:
    AOTCompiledMetaMethod(const Function::AOTCompiledFunction *aotCompiledFunction)
        : aotCompiledFunction(aotCompiledFunction)
    {}
 
    int parameterCount() const { return aotCompiledFunction->types.size() - 1; }
    QMetaType returnMetaType() const { return aotCompiledFunction->types[0]; }
    QMetaType parameterMetaType(int i) const { return aotCompiledFunction->types[i + 1]; }
 
private:
    const Function::AOTCompiledFunction *aotCompiledFunction = nullptr;
};
}
 
void VME::exec(MetaTypesStackFrame *frame, ExecutionEngine *engine)
{
    qt_v4ResolvePendingBreakpointsHook();
    if (engine->checkStackLimits()) {
        frame->setReturnValueUndefined();
        return;
    }
    ExecutionEngineCallDepthRecorder executionEngineCallDepthRecorder(engine);
 
    Function *function = frame->v4Function;
    Q_ASSERT(function->aotCompiledCode);
    Q_TRACE_SCOPE(QQmlV4_function_call, engine, function->name()->toQString(),
                  function->executableCompilationUnit()->fileName(),
                  function->compiledFunction->location.line(),
                  function->compiledFunction->location.column());
    Profiling::FunctionCallProfiler profiler(engine, function); // start execution profiling
 
    const AOTCompiledMetaMethod method(&function->aotCompiledFunction);
    QV4::coerceAndCall(
            engine, &method, frame->returnAndArgValues(),
            frame->returnAndArgTypes(), frame->argc(),
            [frame, engine, function](void **argv, int argc) {
        Q_UNUSED(argc);
 
        QQmlPrivate::AOTCompiledContext aotContext;
        if (auto context = QV4::ExecutionEngine::qmlContext(frame->context()->d())) {
            QV4::Heap::QQmlContextWrapper *wrapper = static_cast<Heap::QmlContext *>(context)->qml();
            aotContext.qmlScopeObject = wrapper->scopeObject;
            aotContext.qmlContext = wrapper->context;
        }
 
        aotContext.engine = engine->jsEngine();
        aotContext.compilationUnit = function->executableCompilationUnit();
        function->aotCompiledCode(&aotContext, argv);
 
        // The tracked-locals storage is a local variable of the AOT-compiled
        // function. We should not be able to use it between here and the
        // popping of the stack frame. However, nulling it is a cheap defense
        // in depth that will make mistaken code crash with a clean null pointer
        // dereference or skip rather than corrupt random stack values.
        frame->setLocals(nullptr);
    });
}
 
ReturnedValue VME::exec(JSTypesStackFrame *frame, ExecutionEngine *engine)
{
    qt_v4ResolvePendingBreakpointsHook();
    CHECK_STACK_LIMITS(engine);
 
    Function *function = frame->v4Function;
    Q_TRACE_SCOPE(QQmlV4_function_call, engine, function->name()->toQString(),
                  function->executableCompilationUnit()->fileName(),
                  function->compiledFunction->location.line(),
                  function->compiledFunction->location.column());
    Profiling::FunctionCallProfiler profiler(engine, function); // start execution profiling
    QV4::Debugging::Debugger *debugger = engine->debugger();
 
#if QT_CONFIG(qml_jit)
    if (debugger == nullptr) {
        // Check for codeRef here. In rare cases the JIT compilation may fail, which leaves us
        // with a (useless) codeRef, but no jittedCode. In that case, don't try to JIT again every
        // time we execute the function, but just interpret instead.
        if (function->codeRef == nullptr) {
            if (engine->canJIT(function))
                QV4::JIT::BaselineJIT(function).generate();
            else
                ++function->interpreterCallCount;
        }
    }
#endif // QT_CONFIG(qml_jit)
 
    // interpreter
    if (debugger)
        debugger->enteringFunction();
 
    ReturnedValue result;
    Q_ASSERT(function->kind != Function::AotCompiled);
    if (function->jittedCode != nullptr && debugger == nullptr) {
        result = function->jittedCode(frame, engine);
    } else {
        // interpreter
        result = interpret(frame, engine, function->codeData);
    }
 
    if (debugger)
        debugger->leavingFunction(result);
 
    return result;
}
 
QV4::ReturnedValue VME::interpret(JSTypesStackFrame *frame, ExecutionEngine *engine, const char *code)
{
    QV4::Function *function = frame->v4Function;
    QV4::Value &accumulator = frame->jsFrame->accumulator.asValue<Value>();
    QV4::ReturnedValue acc = accumulator.asReturnedValue();
    Value *stack = reinterpret_cast<Value *>(frame->jsFrame);
 
    MOTH_JUMP_TABLE;
 
    for (;;) {
    MOTH_DISPATCH()
    Q_UNREACHABLE(); // only reached when the dispatch doesn't jump somewhere
 
    MOTH_BEGIN_INSTR(LoadConst)
        acc = constant(function, index).asReturnedValue();
    MOTH_END_INSTR(LoadConst)
 
    MOTH_BEGIN_INSTR(LoadNull)
        acc = Encode::null();
    MOTH_END_INSTR(LoadNull)
 
    MOTH_BEGIN_INSTR(LoadZero)
        acc = Encode(static_cast<int>(0));
    MOTH_END_INSTR(LoadZero)
 
    MOTH_BEGIN_INSTR(LoadTrue)
        acc = Encode(true);
    MOTH_END_INSTR(LoadTrue)
 
    MOTH_BEGIN_INSTR(LoadFalse)
        acc = Encode(false);
    MOTH_END_INSTR(LoadFalse)
 
    MOTH_BEGIN_INSTR(LoadUndefined)
        acc = Encode::undefined();
    MOTH_END_INSTR(LoadUndefined)
 
    MOTH_BEGIN_INSTR(LoadInt)
        acc = Encode(value);
    MOTH_END_INSTR(LoadInt)
 
    MOTH_BEGIN_INSTR(MoveConst)
        STACK_VALUE(destTemp) = constant(function, constIndex);
    MOTH_END_INSTR(MoveConst)
 
    MOTH_BEGIN_INSTR(LoadReg)
        acc = STACK_VALUE(reg).asReturnedValue();
    MOTH_END_INSTR(LoadReg)
 
    MOTH_BEGIN_INSTR(StoreReg)
        STACK_VALUE(reg) = acc;
    MOTH_END_INSTR(StoreReg)
 
    MOTH_BEGIN_INSTR(MoveReg)
        STACK_VALUE(destReg) = STACK_VALUE(srcReg);
    MOTH_END_INSTR(MoveReg)
 
    MOTH_BEGIN_INSTR(LoadImport)
        acc = function->compilationUnit->imports[index]->asReturnedValue();
    MOTH_END_INSTR(LoadImport)
 
    MOTH_BEGIN_INSTR(LoadLocal)
        auto cc = static_cast<Heap::CallContext *>(STACK_VALUE(CallData::Context).m());
        Q_ASSERT(cc->type != QV4::Heap::CallContext::Type_GlobalContext);
        acc = cc->locals[index].asReturnedValue();
    MOTH_END_INSTR(LoadLocal)
 
    MOTH_BEGIN_INSTR(StoreLocal)
        CHECK_EXCEPTION;
        auto cc = static_cast<Heap::CallContext *>(STACK_VALUE(CallData::Context).m());
        Q_ASSERT(cc->type != QV4::Heap::CallContext::Type_GlobalContext);
        QV4::WriteBarrier::write(engine, cc, cc->locals.values[index].data_ptr(), acc);
    MOTH_END_INSTR(StoreLocal)
 
    MOTH_BEGIN_INSTR(LoadScopedLocal)
        auto cc = getScope(stack, scope);
        acc = cc->locals[index].asReturnedValue();
    MOTH_END_INSTR(LoadScopedLocal)
 
    MOTH_BEGIN_INSTR(StoreScopedLocal)
        CHECK_EXCEPTION;
        auto cc = getScope(stack, scope);
        QV4::WriteBarrier::write(engine, cc, cc->locals.values[index].data_ptr(), acc);
    MOTH_END_INSTR(StoreScopedLocal)
 
    MOTH_BEGIN_INSTR(LoadRuntimeString)
        acc = function->compilationUnit->runtimeStrings[stringId]->asReturnedValue();
    MOTH_END_INSTR(LoadRuntimeString)
 
    MOTH_BEGIN_INSTR(MoveRegExp)
        STACK_VALUE(destReg) = Runtime::RegexpLiteral::call(engine, regExpId);
    MOTH_END_INSTR(MoveRegExp)
 
    MOTH_BEGIN_INSTR(LoadClosure)
        acc = Runtime::Closure::call(engine, value);
    MOTH_END_INSTR(LoadClosure)
 
    MOTH_BEGIN_INSTR(LoadName)
        STORE_IP();
        acc = Runtime::LoadName::call(engine, name);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadName)
 
    MOTH_BEGIN_INSTR(LoadGlobalLookup)
        STORE_IP();
        QV4::Lookup *l = function->executableCompilationUnit()->runtimeLookups + index;
        acc = l->globalGetter(engine);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadGlobalLookup)
 
    MOTH_BEGIN_INSTR(LoadQmlContextPropertyLookup)
        STORE_IP();
        QV4::Lookup *l = function->executableCompilationUnit()->runtimeLookups + index;
        acc = l->contextGetter(engine, nullptr);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadQmlContextPropertyLookup)
 
    MOTH_BEGIN_INSTR(StoreNameStrict)
        STORE_IP();
        STORE_ACC();
        Runtime::StoreNameStrict::call(engine, name, accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(StoreNameStrict)
 
    MOTH_BEGIN_INSTR(StoreNameSloppy)
        STORE_IP();
        STORE_ACC();
        Runtime::StoreNameSloppy::call(engine, name, accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(StoreNameSloppy)
 
    MOTH_BEGIN_INSTR(LoadElement)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::LoadElement::call(engine, STACK_VALUE(base), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadElement)
 
    MOTH_BEGIN_INSTR(StoreElement)
        STORE_IP();
        STORE_ACC();
        Runtime::StoreElement::call(engine, STACK_VALUE(base), STACK_VALUE(index), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(StoreElement)
 
    MOTH_BEGIN_INSTR(LoadProperty)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::LoadProperty::call(engine, accumulator, name);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadProperty)
 
    MOTH_BEGIN_INSTR(LoadOptionalProperty)
        STORE_IP();
        STORE_ACC();
        if (accumulator.isNullOrUndefined()) {
            acc = Encode::undefined();
            code += offset;
        } else {
            acc = Runtime::LoadProperty::call(engine, accumulator, name);
        }
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadOptionalProperty)
 
    MOTH_BEGIN_INSTR(GetLookup)
        STORE_IP();
        STORE_ACC();
 
        QV4::Lookup *l = function->executableCompilationUnit()->runtimeLookups + index;
 
        if (accumulator.isNullOrUndefined()) {
            const QString message =
                    QStringLiteral("Cannot read property '%1' of %2")
                            .arg(engine->currentStackFrame->v4Function->compilationUnit
                                         ->runtimeStrings[l->nameIndex]
                                         ->toQString(),
                                 accumulator.toQStringNoThrow());
            acc = engine->throwTypeError(message);
            goto handleUnwind;
        }
 
        acc = l->getter(engine, accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(GetLookup)
 
    MOTH_BEGIN_INSTR(GetOptionalLookup)
        STORE_IP();
        STORE_ACC();
 
        QV4::Lookup *l = function->executableCompilationUnit()->runtimeLookups + index;
 
        if (accumulator.isNullOrUndefined()) {
            code += offset;
        } else {
            acc = l->getter(engine, accumulator);
        }
    CHECK_EXCEPTION;
    MOTH_END_INSTR(GetOptionalLookup)
 
    MOTH_BEGIN_INSTR(StoreProperty)
        STORE_IP();
        STORE_ACC();
        Runtime::StoreProperty::call(engine, STACK_VALUE(base), name, accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(StoreProperty)
 
    MOTH_BEGIN_INSTR(SetLookup)
        STORE_IP();
        STORE_ACC();
        QV4::Lookup *l = function->executableCompilationUnit()->runtimeLookups + index;
        if (!l->setter(engine, STACK_VALUE(base), accumulator) && function->isStrict())
            engine->throwTypeError();
        CHECK_EXCEPTION;
    MOTH_END_INSTR(SetLookup)
 
    MOTH_BEGIN_INSTR(LoadSuperProperty)
        STORE_IP();
        acc = Runtime::LoadSuperProperty::call(engine, STACK_VALUE(property));
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadSuperProperty)
 
    MOTH_BEGIN_INSTR(StoreSuperProperty)
        STORE_IP();
        STORE_ACC();
        Runtime::StoreSuperProperty::call(engine, STACK_VALUE(property), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(StoreSuperProperty)
 
    MOTH_BEGIN_INSTR(Yield)
        frame->setYield(code);
        frame->setYieldIsIterator(false);
        return acc;
    MOTH_END_INSTR(Yield)
 
    MOTH_BEGIN_INSTR(YieldStar)
        frame->setYield(code);
        frame->setYieldIsIterator(true);
        return acc;
    MOTH_END_INSTR(YieldStar)
 
    MOTH_BEGIN_INSTR(Resume)
        // check exception, in case the generator was called with throw() or return()
        if (engine->hasException) {
            // an empty value indicates that the generator was called with return()
            if (engine->exceptionValue->asReturnedValue() != Value::emptyValue().asReturnedValue())
                goto handleUnwind;
            engine->hasException = false;
            *engine->exceptionValue = Value::undefinedValue();
        } else {
            code += offset;
        }
    MOTH_END_INSTR(Resume)
 
    MOTH_BEGIN_INSTR(IteratorNextForYieldStar)
        STORE_ACC();
        acc = Runtime::IteratorNextForYieldStar::call(engine, accumulator, STACK_VALUE(iterator), &STACK_VALUE(object));
        if (ACC.toBoolean())
            code += offset;
    MOTH_END_INSTR(IteratorNextForYieldStar)
 
    MOTH_BEGIN_INSTR(CallValue)
        STORE_IP();
        Value func = STACK_VALUE(name);
        if (Q_UNLIKELY(!func.isFunctionObject())) {
            acc = engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
            goto handleUnwind;
        }
        Value undef = Value::undefinedValue();
        acc = static_cast<const FunctionObject &>(func).call(&undef, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallValue)
 
    MOTH_BEGIN_INSTR(CallWithReceiver)
        STORE_IP();
        Value func = STACK_VALUE(name);
        if (Q_UNLIKELY(!func.isFunctionObject())) {
            acc = engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
            goto handleUnwind;
        }
        acc = static_cast<const FunctionObject &>(func).call(stack + thisObject, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallWithReceiver)
 
    MOTH_BEGIN_INSTR(CallProperty)
        STORE_IP();
        acc = Runtime::CallProperty::call(engine, STACK_VALUE(base), name, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallProperty)
 
    MOTH_BEGIN_INSTR(CallPropertyLookup)
        STORE_IP();
        Lookup *l = function->executableCompilationUnit()->runtimeLookups + lookupIndex;
 
        if (STACK_VALUE(base).isNullOrUndefined()) {
            const QString message =
                    QStringLiteral("Cannot call method '%1' of %2")
                            .arg(engine->currentStackFrame->v4Function->compilationUnit
                                         ->runtimeStrings[l->nameIndex]
                                         ->toQString(),
                                 STACK_VALUE(base).toQStringNoThrow());
            acc = engine->throwTypeError(message);
            goto handleUnwind;
        }
 
        // ok to have the value on the stack here
        Value f = Value::fromReturnedValue(l->getter(engine, STACK_VALUE(base)));
 
        if (Q_LIKELY(f.isFunctionObject())) {
            acc = static_cast<FunctionObject &>(f).call(stack + base, stack + argv, argc);
        } else if (QmlSignalHandler *handler = f.as<QmlSignalHandler>()) {
            acc = handler->call(stack + base, stack + argv, argc);
        } else {
            const QString message =
                    QStringLiteral("Property '%1' of object %2 is not a function")
                            .arg(engine->currentStackFrame->v4Function->compilationUnit
                                         ->runtimeStrings[l->nameIndex]
                                         ->toQString(),
                                 STACK_VALUE(base).toQStringNoThrow());
            acc = engine->throwTypeError(message);
            goto handleUnwind;
        }
 
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallPropertyLookup)
 
    MOTH_BEGIN_INSTR(CallName)
        STORE_IP();
        acc = Runtime::CallName::call(engine, name, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallName)
 
    MOTH_BEGIN_INSTR(CallPossiblyDirectEval)
        STORE_IP();
        acc = Runtime::CallPossiblyDirectEval::call(engine, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallPossiblyDirectEval)
 
    MOTH_BEGIN_INSTR(CallGlobalLookup)
        STORE_IP();
        acc = Runtime::CallGlobalLookup::call(engine, index, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallGlobalLookup)
 
    MOTH_BEGIN_INSTR(CallQmlContextPropertyLookup)
        STORE_IP();
        acc = Runtime::CallQmlContextPropertyLookup::call(engine, index, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallQmlContextPropertyLookup)
 
    MOTH_BEGIN_INSTR(CallWithSpread)
        STORE_IP();
        acc = Runtime::CallWithSpread::call(engine, STACK_VALUE(func), STACK_VALUE(thisObject), stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CallWithSpread)
 
    MOTH_BEGIN_INSTR(TailCall)
        STORE_IP();
        *engine->jsAlloca(1) = Primitive::fromInt32(argc);
        *engine->jsAlloca(1) = Primitive::fromInt32(argv);
        *engine->jsAlloca(1) = STACK_VALUE(thisObject);
        *engine->jsAlloca(1) = STACK_VALUE(func);
        return Runtime::TailCall::call(frame, engine);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(TailCall)
 
    MOTH_BEGIN_INSTR(Construct)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::Construct::call(engine, STACK_VALUE(func), ACC, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(Construct)
 
    MOTH_BEGIN_INSTR(ConstructWithSpread)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::ConstructWithSpread::call(engine, STACK_VALUE(func), ACC, stack + argv, argc);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(ConstructWithSpread)
 
    MOTH_BEGIN_INSTR(SetUnwindHandler)
        frame->unwindHandler = offset ? code + offset : nullptr;
    MOTH_END_INSTR(SetUnwindHandler)
 
    MOTH_BEGIN_INSTR(UnwindDispatch)
        CHECK_EXCEPTION;
        if (frame->unwindLevel) {
            --frame->unwindLevel;
            if (frame->unwindLevel)
                goto handleUnwind;
            code = frame->unwindLabel;
        }
    MOTH_END_INSTR(UnwindDispatch)
 
    MOTH_BEGIN_INSTR(UnwindToLabel)
        frame->unwindLevel = level;
        frame->unwindLabel = code + offset;
        goto handleUnwind;
    MOTH_END_INSTR(UnwindToLabel)
 
    MOTH_BEGIN_INSTR(DeadTemporalZoneCheck)
        if (ACC.isEmpty()) {
            STORE_IP();
            Runtime::ThrowReferenceError::call(engine, name);
            goto handleUnwind;
        }
    MOTH_END_INSTR(DeadTemporalZoneCheck)
 
    MOTH_BEGIN_INSTR(ThrowException)
        STORE_IP();
        STORE_ACC();
        Runtime::ThrowException::call(engine, accumulator);
        goto handleUnwind;
    MOTH_END_INSTR(ThrowException)
 
    MOTH_BEGIN_INSTR(GetException)
        acc = engine->hasException ? engine->exceptionValue->asReturnedValue()
                                   : Value::emptyValue().asReturnedValue();
        engine->hasException = false;
    MOTH_END_INSTR(GetException)
 
    MOTH_BEGIN_INSTR(SetException)
        if (acc != Value::emptyValue().asReturnedValue()) {
            *engine->exceptionValue = acc;
            engine->hasException = true;
        }
    MOTH_END_INSTR(SetException)
 
    MOTH_BEGIN_INSTR(PushCatchContext)
        Runtime::PushCatchContext::call(engine, index, name);
    MOTH_END_INSTR(PushCatchContext)
 
    MOTH_BEGIN_INSTR(CreateCallContext)
        Runtime::PushCallContext::call(frame);
    MOTH_END_INSTR(CreateCallContext)
 
    MOTH_BEGIN_INSTR(PushWithContext)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::PushWithContext::call(engine, STACK_VALUE(CallData::Accumulator));
        CHECK_EXCEPTION;
    MOTH_END_INSTR(PushWithContext)
 
    MOTH_BEGIN_INSTR(PushBlockContext)
        STORE_ACC();
        Runtime::PushBlockContext::call(engine, index);
    MOTH_END_INSTR(PushBlockContext)
 
    MOTH_BEGIN_INSTR(CloneBlockContext)
        STORE_ACC();
        Runtime::CloneBlockContext::call(engine);
    MOTH_END_INSTR(CloneBlockContext)
 
    MOTH_BEGIN_INSTR(PushScriptContext)
        Runtime::PushScriptContext::call(engine, index);
    MOTH_END_INSTR(PushScriptContext)
 
    MOTH_BEGIN_INSTR(PopScriptContext)
        Runtime::PopScriptContext::call(engine);
    MOTH_END_INSTR(PopScriptContext)
 
    MOTH_BEGIN_INSTR(PopContext)
        ExecutionContext *c = static_cast<ExecutionContext *>(stack + CallData::Context);
        STACK_VALUE(CallData::Context) = c->d()->outer;
    MOTH_END_INSTR(PopContext)
 
    MOTH_BEGIN_INSTR(GetIterator)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::GetIterator::call(engine, accumulator, iterator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(GetIterator)
 
    MOTH_BEGIN_INSTR(IteratorNext)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::IteratorNext::call(engine, accumulator, &STACK_VALUE(value));
        if (ACC.toBoolean())
            code += offset;
    MOTH_END_INSTR(IteratorNext)
 
    MOTH_BEGIN_INSTR(IteratorClose)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::IteratorClose::call(engine, accumulator);
    MOTH_END_INSTR(IteratorClose)
 
    MOTH_BEGIN_INSTR(DestructureRestElement)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::DestructureRestElement::call(engine, ACC);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(DestructureRestElement)
 
    MOTH_BEGIN_INSTR(DeleteProperty)
        acc = Runtime::DeleteProperty::call(engine, function, STACK_VALUE(base), STACK_VALUE(index));
        CHECK_EXCEPTION;
    MOTH_END_INSTR(DeleteProperty)
 
    MOTH_BEGIN_INSTR(DeleteName)
        acc = Runtime::DeleteName::call(engine, function, name);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(DeleteName)
 
    MOTH_BEGIN_INSTR(TypeofName)
        acc = Runtime::TypeofName::call(engine, name);
    MOTH_END_INSTR(TypeofName)
 
    MOTH_BEGIN_INSTR(TypeofValue)
        STORE_ACC();
        acc = Runtime::TypeofValue::call(engine, accumulator);
    MOTH_END_INSTR(TypeofValue)
 
    MOTH_BEGIN_INSTR(DeclareVar)
        Runtime::DeclareVar::call(engine, isDeletable, varName);
    MOTH_END_INSTR(DeclareVar)
 
    MOTH_BEGIN_INSTR(DefineArray)
        QV4::Value *arguments = stack + args;
        acc = Runtime::ArrayLiteral::call(engine, arguments, argc);
    MOTH_END_INSTR(DefineArray)
 
    MOTH_BEGIN_INSTR(DefineObjectLiteral)
        QV4::Value *arguments = stack + args;
        acc = Runtime::ObjectLiteral::call(engine, internalClassId, arguments, argc);
    MOTH_END_INSTR(DefineObjectLiteral)
 
    MOTH_BEGIN_INSTR(CreateClass)
        acc = Runtime::CreateClass::call(engine, classIndex, STACK_VALUE(heritage), stack + computedNames);
    MOTH_END_INSTR(CreateClass)
 
    MOTH_BEGIN_INSTR(CreateMappedArgumentsObject)
        acc = Runtime::CreateMappedArgumentsObject::call(engine);
    MOTH_END_INSTR(CreateMappedArgumentsObject)
 
    MOTH_BEGIN_INSTR(CreateUnmappedArgumentsObject)
        acc = Runtime::CreateUnmappedArgumentsObject::call(engine);
    MOTH_END_INSTR(CreateUnmappedArgumentsObject)
 
    MOTH_BEGIN_INSTR(CreateRestParameter)
        acc = Runtime::CreateRestParameter::call(engine, argIndex);
    MOTH_END_INSTR(CreateRestParameter)
 
    MOTH_BEGIN_INSTR(ConvertThisToObject)
        STORE_ACC();
        stack[CallData::This] = Runtime::ConvertThisToObject::call(
                    engine, STACK_VALUE(CallData::This));
        CHECK_EXCEPTION;
    MOTH_END_INSTR(ConvertThisToObject)
 
    MOTH_BEGIN_INSTR(LoadSuperConstructor)
        acc = Runtime::LoadSuperConstructor::call(engine, STACK_VALUE(CallData::Function));
        CHECK_EXCEPTION;
    MOTH_END_INSTR(LoadSuperConstructor)
 
    MOTH_BEGIN_INSTR(ToObject)
        STORE_ACC();
        acc = ACC.toObject(engine)->asReturnedValue();
        CHECK_EXCEPTION;
    MOTH_END_INSTR(ToObject)
 
    MOTH_BEGIN_INSTR(Jump)
        code += offset;
    MOTH_END_INSTR(Jump)
 
    MOTH_BEGIN_INSTR(JumpTrue)
        bool takeJump;
        if (Q_LIKELY(ACC.integerCompatible()))
            takeJump = ACC.int_32();
        else
            takeJump = ACC.toBoolean();
        if (takeJump)
            code += offset;
    MOTH_END_INSTR(JumpTrue)
 
    MOTH_BEGIN_INSTR(JumpFalse)
        bool takeJump;
        if (Q_LIKELY(ACC.integerCompatible()))
            takeJump = !ACC.int_32();
        else
            takeJump = !ACC.toBoolean();
        if (takeJump)
            code += offset;
    MOTH_END_INSTR(JumpFalse)
 
    MOTH_BEGIN_INSTR(JumpNoException)
        if (!engine->hasException)
            code += offset;
    MOTH_END_INSTR(JumpNoException)
 
    MOTH_BEGIN_INSTR(JumpNotUndefined)
        if (Q_LIKELY(acc != QV4::Encode::undefined()))
            code += offset;
    MOTH_END_INSTR(JumpNotUndefined)
 
    MOTH_BEGIN_INSTR(CheckException)
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CheckException)
 
    MOTH_BEGIN_INSTR(CmpEqNull)
        acc = Encode(ACC.isNullOrUndefined());
    MOTH_END_INSTR(CmpEqNull)
 
    MOTH_BEGIN_INSTR(CmpNeNull)
        acc = Encode(!ACC.isNullOrUndefined());
    MOTH_END_INSTR(CmpNeNull)
 
    MOTH_BEGIN_INSTR(CmpEqInt)
        if (ACC.isIntOrBool()) {
            acc = Encode(ACC.int_32() == lhs);
        } else {
            STORE_ACC();
            acc = Encode(compareEqualInt(accumulator, ACC, lhs));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpEqInt)
 
    MOTH_BEGIN_INSTR(CmpNeInt)
        if (ACC.isIntOrBool()) {
            acc = Encode(bool(ACC.int_32() != lhs));
        } else {
            STORE_ACC();
            acc = Encode(!compareEqualInt(accumulator, ACC, lhs));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpNeInt)
 
    MOTH_BEGIN_INSTR(CmpEq)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.asReturnedValue() == ACC.asReturnedValue())) {
            acc = Encode(!ACC.isNaN());
        } else if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(left.int_32() == ACC.int_32());
        } else {
            STORE_ACC();
            acc = Encode(bool(Runtime::CompareEqual::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpEq)
 
    MOTH_BEGIN_INSTR(CmpNe)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(bool(left.int_32() != ACC.int_32()));
        } else {
            STORE_ACC();
            acc = Encode(bool(!Runtime::CompareEqual::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpNe)
 
    MOTH_BEGIN_INSTR(CmpGt)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(left.int_32() > ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() > ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Encode(bool(Runtime::CompareGreaterThan::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpGt)
 
    MOTH_BEGIN_INSTR(CmpGe)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(left.int_32() >= ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() >= ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Encode(bool(Runtime::CompareGreaterEqual::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpGe)
 
    MOTH_BEGIN_INSTR(CmpLt)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(left.int_32() < ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() < ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Encode(bool(Runtime::CompareLessThan::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpLt)
 
    MOTH_BEGIN_INSTR(CmpLe)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(left.isInteger() && ACC.isInteger())) {
            acc = Encode(left.int_32() <= ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() <= ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Encode(bool(Runtime::CompareLessEqual::call(left, accumulator)));
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpLe)
 
    MOTH_BEGIN_INSTR(CmpStrictEqual)
        if (STACK_VALUE(lhs).rawValue() == ACC.rawValue() && !ACC.isNaN()) {
            acc = Encode(true);
        } else {
            STORE_ACC();
            acc = Runtime::StrictEqual::call(STACK_VALUE(lhs), accumulator);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(CmpStrictEqual)
 
    MOTH_BEGIN_INSTR(CmpStrictNotEqual)
        if (STACK_VALUE(lhs).rawValue() != ACC.rawValue() || ACC.isNaN()) {
            STORE_ACC();
            acc = Runtime::StrictNotEqual::call(STACK_VALUE(lhs), accumulator);
            CHECK_EXCEPTION;
        } else {
            acc = Encode(false);
        }
    MOTH_END_INSTR(CmpStrictNotEqual)
 
    MOTH_BEGIN_INSTR(CmpIn)
        STORE_IP();
        STORE_ACC();
        acc = Runtime::In::call(engine, STACK_VALUE(lhs), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CmpIn)
 
    MOTH_BEGIN_INSTR(CmpInstanceOf)
        STORE_ACC();
        acc = Runtime::Instanceof::call(engine, STACK_VALUE(lhs), ACC);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(CmpInstanceOf)
 
    MOTH_BEGIN_INSTR(UNot)
        if (ACC.integerCompatible()) {
            acc = Encode(!static_cast<bool>(ACC.int_32()));
        } else {
            acc = Encode(!Value::toBooleanImpl(ACC));
        }
    MOTH_END_INSTR(UNot)
 
    MOTH_BEGIN_INSTR(UPlus)
        if (Q_UNLIKELY(!ACC.isNumber())) {
            acc = Encode(ACC.toNumberImpl());
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(UPlus)
 
    MOTH_BEGIN_INSTR(UMinus)
        if (Q_LIKELY(ACC.integerCompatible())) {
            int a = ACC.int_32();
            if (a == 0 || a == std::numeric_limits<int>::min()) {
                acc = Encode(-static_cast<double>(a));
            } else {
                acc = sub_int32(0, ACC.int_32());
            }
        } else if (ACC.isDouble()) {
            acc ^= (1ull << 63); // simply flip sign bit
        } else {
            acc = Encode(-ACC.toNumberImpl());
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(UMinus)
 
    MOTH_BEGIN_INSTR(UCompl)
        VALUE_TO_INT(a, ACC);
        acc = Encode(~a);
    MOTH_END_INSTR(UCompl)
 
    MOTH_BEGIN_INSTR(Increment)
        if (Q_LIKELY(ACC.integerCompatible())) {
            acc = add_int32(ACC.int_32(), 1);
        } else if (ACC.isDouble()) {
            acc = QV4::Encode(ACC.doubleValue() + 1.);
        } else {
            acc = Encode(ACC.toNumberImpl() + 1.);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(Increment)
 
    MOTH_BEGIN_INSTR(Decrement)
        if (Q_LIKELY(ACC.integerCompatible())) {
            acc = sub_int32(ACC.int_32(), 1);
        } else if (ACC.isDouble()) {
            acc = QV4::Encode(ACC.doubleValue() - 1.);
        } else {
            acc = Encode(ACC.toNumberImpl() - 1.);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(Decrement)
 
    MOTH_BEGIN_INSTR(Add)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(Value::integerCompatible(left, ACC))) {
            acc = add_int32(left.int_32(), ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() + ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Runtime::Add::call(engine, left, accumulator);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(Add)
 
    MOTH_BEGIN_INSTR(Sub)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(Value::integerCompatible(left, ACC))) {
            acc = sub_int32(left.int_32(), ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() - ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Runtime::Sub::call(left, accumulator);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(Sub)
 
    MOTH_BEGIN_INSTR(As)
        const Value left = STACK_VALUE(lhs);
        STORE_ACC();
        acc = Runtime::As::call(engine, left, accumulator);
    MOTH_END_INSTR(As)
 
    MOTH_BEGIN_INSTR(Exp)
        const Value left = STACK_VALUE(lhs);
        double base = left.toNumber();
        double exp = ACC.toNumber();
        acc = Encode(QQmlPrivate::jsExponentiate(base, exp));
    MOTH_END_INSTR(Exp)
 
    MOTH_BEGIN_INSTR(Mul)
        const Value left = STACK_VALUE(lhs);
        if (Q_LIKELY(Value::integerCompatible(left, ACC))) {
            acc = mul_int32(left.int_32(), ACC.int_32());
        } else if (left.isNumber() && ACC.isNumber()) {
            acc = Encode(left.asDouble() * ACC.asDouble());
        } else {
            STORE_ACC();
            acc = Runtime::Mul::call(left, accumulator);
            CHECK_EXCEPTION;
        }
    MOTH_END_INSTR(Mul)
 
    MOTH_BEGIN_INSTR(Div)
        STORE_ACC();
        acc = Runtime::Div::call(STACK_VALUE(lhs), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(Div)
 
    MOTH_BEGIN_INSTR(Mod)
        STORE_ACC();
        acc = Runtime::Mod::call(STACK_VALUE(lhs), accumulator);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(Mod)
 
    MOTH_BEGIN_INSTR(BitAnd)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(l & a);
    MOTH_END_INSTR(BitAnd)
 
    MOTH_BEGIN_INSTR(BitOr)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(l | a);
    MOTH_END_INSTR(BitOr)
 
    MOTH_BEGIN_INSTR(BitXor)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(l ^ a);
    MOTH_END_INSTR(BitXor)
 
    MOTH_BEGIN_INSTR(UShr)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(static_cast<uint>(l) >> uint(a & 0x1f));
    MOTH_END_INSTR(UShr)
 
    MOTH_BEGIN_INSTR(Shr)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(l >> (a & 0x1f));
    MOTH_END_INSTR(Shr)
 
    MOTH_BEGIN_INSTR(Shl)
        VALUE_TO_INT(l, STACK_VALUE(lhs));
        VALUE_TO_INT(a, ACC);
        acc = Encode(l << (a & 0x1f));
    MOTH_END_INSTR(Shl)
 
    MOTH_BEGIN_INSTR(BitAndConst)
        VALUE_TO_INT(a, ACC);
        acc = Encode(a & rhs);
        CHECK_EXCEPTION;
    MOTH_END_INSTR(BitAndConst)
 
    MOTH_BEGIN_INSTR(BitOrConst)
        VALUE_TO_INT(a, ACC);
        acc = Encode(a | rhs);
    MOTH_END_INSTR(BitOrConst)
 
    MOTH_BEGIN_INSTR(BitXorConst)
        VALUE_TO_INT(a, ACC);
        acc = Encode(a ^ rhs);
    MOTH_END_INSTR(BitXorConst)
 
    MOTH_BEGIN_INSTR(UShrConst)
        acc = Encode(ACC.toUInt32() >> uint(rhs));
    MOTH_END_INSTR(UShrConst)
 
    MOTH_BEGIN_INSTR(ShrConst)
        VALUE_TO_INT(a, ACC);
        acc = Encode(a >> rhs);
    MOTH_END_INSTR(ShrConst)
 
    MOTH_BEGIN_INSTR(ShlConst)
        VALUE_TO_INT(a, ACC);
        acc = Encode(a << rhs);
    MOTH_END_INSTR(ShlConst)
 
    MOTH_BEGIN_INSTR(Ret)
        return acc;
    MOTH_END_INSTR(Ret)
 
    MOTH_BEGIN_INSTR(InitializeBlockDeadTemporalZone)
        acc = Encode(Value::emptyValue());
        for (int i = firstReg, end = firstReg + count; i < end; ++i)
            STACK_VALUE(i) = acc;
    MOTH_END_INSTR(InitializeBlockDeadTemporalZone)
 
    MOTH_BEGIN_INSTR(ThrowOnNullOrUndefined)
        if (Value::fromReturnedValue(acc).isNullOrUndefined()) {
            engine->throwTypeError();
            goto handleUnwind;
        }
    MOTH_END_INSTR(ThrowOnNullOrUndefined)
 
    MOTH_BEGIN_INSTR(GetTemplateObject)
        acc = Runtime::GetTemplateObject::call(function, index);
    MOTH_END_INSTR(GetTemplateObject)
 
    MOTH_BEGIN_INSTR(Debug)
#if QT_CONFIG(qml_debug)
        STORE_IP();
        debug_slowPath(engine);
#endif // QT_CONFIG(qml_debug)
    MOTH_END_INSTR(Debug)
 
    handleUnwind:
        // We do start the exception handler in case of isInterrupted. The exception handler will
        // immediately abort, due to the same isInterrupted. We don't skip the exception handler
        // because the current behavior is easier to implement in the JIT.
        Q_ASSERT(engine->hasException || engine->isInterrupted.loadRelaxed() || frame->unwindLevel);
        if (!frame->unwindHandler) {
            acc = Encode::undefined();
            return acc;
        }
        code = frame->unwindHandler;
    }
}