Merge branch 'master' of ssh://codereview.qt-project.org:29418/playground/v4vm into v4

This is the initial merge of the v4vm JS engine, designed specifically for QML.

The engine is tested on Linux and Mac OS X, works on x86, x86-64 and ARM.

Change-Id: I826b72cfa3d3575007b70d78604080582db568db

Reviewed-by: Lars Knoll <lars.knoll@digia.com>

7 files changed, 2103 insertions, 0 deletions

diff --git a/src/qml/qml/v4vm/moth/moth.pri b/src/qml/qml/v4vm/moth/moth.pri
new file mode 100644
index 0000000000..73bd893286
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/moth.pri
@@ -0,0 +1,13 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/qv4isel_moth_p.h \
+    $$PWD/qv4instr_moth_p.h \
+    $$PWD/qv4vme_moth_p.h
+
+SOURCES += \
+    $$PWD/qv4isel_moth.cpp \
+    $$PWD/qv4instr_moth.cpp \
+    $$PWD/qv4vme_moth.cpp
+
+#DEFINES += DO_TRACE_INSTR
diff --git a/src/qml/qml/v4vm/moth/qv4instr_moth.cpp b/src/qml/qml/v4vm/moth/qv4instr_moth.cpp
new file mode 100644
index 0000000000..a2bad39e00
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4instr_moth.cpp
@@ -0,0 +1,15 @@
+#include "qv4instr_moth_p.h"
+
+using namespace QQmlJS;
+using namespace QQmlJS::Moth;
+
+int Instr::size(Type type)
+{
+#define MOTH_RETURN_INSTR_SIZE(I, FMT) case I: return InstrMeta<(int)I>::Size;
+    switch (type) {
+    FOR_EACH_MOTH_INSTR(MOTH_RETURN_INSTR_SIZE)
+    default: return 0;
+    }
+#undef MOTH_RETURN_INSTR_SIZE
+}
+
diff --git a/src/qml/qml/v4vm/moth/qv4instr_moth_p.h b/src/qml/qml/v4vm/moth/qv4instr_moth_p.h
new file mode 100644
index 0000000000..b29fb13a74
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4instr_moth_p.h
@@ -0,0 +1,527 @@
+#ifndef QV4INSTR_MOTH_P_H
+#define QV4INSTR_MOTH_P_H
+
+#include <QtCore/qglobal.h>
+#include "qv4object.h"
+
+#define FOR_EACH_MOTH_INSTR(F) \
+    F(Ret, ret) \
+    F(LoadValue, loadValue) \
+    F(LoadClosure, loadClosure) \
+    F(MoveTemp, moveTemp) \
+    F(LoadName, loadName) \
+    F(StoreName, storeName) \
+    F(LoadElement, loadElement) \
+    F(StoreElement, storeElement) \
+    F(LoadProperty, loadProperty) \
+    F(StoreProperty, storeProperty) \
+    F(Push, push) \
+    F(EnterTry, enterTry) \
+    F(CallValue, callValue) \
+    F(CallProperty, callProperty) \
+    F(CallElement, callElement) \
+    F(CallActivationProperty, callActivationProperty) \
+    F(CallBuiltinThrow, callBuiltinThrow) \
+    F(CallBuiltinFinishTry, callBuiltinFinishTry) \
+    F(CallBuiltinPushScope, callBuiltinPushScope) \
+    F(CallBuiltinPopScope, callBuiltinPopScope) \
+    F(CallBuiltinForeachIteratorObject, callBuiltinForeachIteratorObject) \
+    F(CallBuiltinForeachNextPropertyName, callBuiltinForeachNextPropertyName) \
+    F(CallBuiltinDeleteMember, callBuiltinDeleteMember) \
+    F(CallBuiltinDeleteSubscript, callBuiltinDeleteSubscript) \
+    F(CallBuiltinDeleteName, callBuiltinDeleteName) \
+    F(CallBuiltinTypeofMember, callBuiltinTypeofMember) \
+    F(CallBuiltinTypeofSubscript, callBuiltinTypeofSubscript) \
+    F(CallBuiltinTypeofName, callBuiltinTypeofName) \
+    F(CallBuiltinTypeofValue, callBuiltinTypeofValue) \
+    F(CallBuiltinPostIncMember, callBuiltinPostIncMember) \
+    F(CallBuiltinPostIncSubscript, callBuiltinPostIncSubscript) \
+    F(CallBuiltinPostIncName, callBuiltinPostIncName) \
+    F(CallBuiltinPostIncValue, callBuiltinPostIncValue) \
+    F(CallBuiltinPostDecMember, callBuiltinPostDecMember) \
+    F(CallBuiltinPostDecSubscript, callBuiltinPostDecSubscript) \
+    F(CallBuiltinPostDecName, callBuiltinPostDecName) \
+    F(CallBuiltinPostDecValue, callBuiltinPostDecValue) \
+    F(CallBuiltinDeclareVar, callBuiltinDeclareVar) \
+    F(CallBuiltinDefineGetterSetter, callBuiltinDefineGetterSetter) \
+    F(CallBuiltinDefineProperty, callBuiltinDefineProperty) \
+    F(CallBuiltinDefineArray, callBuiltinDefineArray) \
+    F(CreateValue, createValue) \
+    F(CreateProperty, createProperty) \
+    F(CreateActivationProperty, createActivationProperty) \
+    F(Jump, jump) \
+    F(CJump, cjump) \
+    F(Unop, unop) \
+    F(Binop, binop) \
+    F(LoadThis, loadThis) \
+    F(InplaceElementOp, inplaceElementOp) \
+    F(InplaceMemberOp, inplaceMemberOp) \
+    F(InplaceNameOp, inplaceNameOp)
+
+#if defined(Q_CC_GNU) && (!defined(Q_CC_INTEL) || __INTEL_COMPILER >= 1200)
+#  define MOTH_THREADED_INTERPRETER
+#endif
+
+#define MOTH_INSTR_ALIGN_MASK (Q_ALIGNOF(QQmlJS::Moth::Instr) - 1)
+
+#ifdef MOTH_THREADED_INTERPRETER
+#  define MOTH_INSTR_HEADER void *code;
+#else
+#  define MOTH_INSTR_HEADER quint8 instructionType;
+#endif
+
+#define MOTH_INSTR_ENUM(I, FMT)  I,
+#define MOTH_INSTR_SIZE(I, FMT) ((sizeof(QQmlJS::Moth::Instr::instr_##FMT) + MOTH_INSTR_ALIGN_MASK) & ~MOTH_INSTR_ALIGN_MASK)
+
+
+namespace QQmlJS {
+namespace Moth {
+
+union Instr
+{
+    struct Param {
+        enum {
+            ValueType    = 0,
+            ArgumentType = 1,
+            LocalType    = 2,
+            TempType     = 3,
+            ScopedLocalType  = 4
+        };
+        VM::Value value;
+        unsigned type  : 3;
+        unsigned scope : 29;
+        unsigned index;
+
+        bool isValue() const { return type == ValueType; }
+        bool isArgument() const { return type == ArgumentType; }
+        bool isLocal() const { return type == LocalType; }
+        bool isTemp() const { return type == TempType; }
+        bool isScopedLocal() const { return type == ScopedLocalType; }
+
+        static Param createValue(const VM::Value &v)
+        {
+            Param p;
+            p.type = ValueType;
+            p.scope = 0;
+            p.value = v;
+            return p;
+        }
+
+        static Param createArgument(unsigned idx, uint scope)
+        {
+            Param p;
+            p.type = ArgumentType;
+            p.scope = scope;
+            p.index = idx;
+            return p;
+        }
+
+        static Param createLocal(unsigned idx)
+        {
+            Param p;
+            p.type = LocalType;
+            p.scope = 0;
+            p.index = idx;
+            return p;
+        }
+
+        static Param createTemp(unsigned idx)
+        {
+            Param p;
+            p.type = TempType;
+            p.scope = 0;
+            p.index = idx;
+            return p;
+        }
+
+        static Param createScopedLocal(unsigned idx, uint scope)
+        {
+            Param p;
+            p.type = ScopedLocalType;
+            p.scope = scope;
+            p.index = idx;
+            return p;
+        }
+    };
+
+    enum Type {
+        FOR_EACH_MOTH_INSTR(MOTH_INSTR_ENUM)
+    };
+
+    struct instr_common {
+        MOTH_INSTR_HEADER
+    };
+    struct instr_ret {
+        MOTH_INSTR_HEADER
+        Param result;
+    }; 
+    struct instr_loadValue {
+        MOTH_INSTR_HEADER
+        Param value;
+        Param result;
+    };
+    struct instr_moveTemp {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_loadClosure {
+        MOTH_INSTR_HEADER
+        VM::Function *value;
+        Param result;
+    };
+    struct instr_loadName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param result;
+    };
+    struct instr_storeName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param source;
+    };
+    struct instr_loadProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param base;
+        Param result;
+    };
+    struct instr_storeProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param base;
+        Param source;
+    };
+    struct instr_loadElement {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param result;
+    };
+    struct instr_storeElement {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param source;
+    };
+    struct instr_push {
+        MOTH_INSTR_HEADER
+        quint32 value;
+    };
+    struct instr_enterTry {
+        MOTH_INSTR_HEADER
+        ptrdiff_t tryOffset;
+        ptrdiff_t catchOffset;
+        VM::String *exceptionVarName;
+        Param exceptionVar;
+    };
+    struct instr_callValue {
+        MOTH_INSTR_HEADER
+        quint32 argc;
+        quint32 args;
+        Param dest;
+        Param result;
+    };
+    struct instr_callProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        quint32 argc;
+        quint32 args;
+        Param base;
+        Param result;
+    };
+    struct instr_callElement {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        quint32 argc;
+        quint32 args;
+        Param result;
+    };
+    struct instr_callActivationProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        quint32 argc;
+        quint32 args;
+        Param result;
+    };
+    struct instr_callBuiltinThrow {
+        MOTH_INSTR_HEADER
+        Param arg;
+    };
+    struct instr_callBuiltinFinishTry {
+        MOTH_INSTR_HEADER
+    };
+    struct instr_callBuiltinPushScope {
+        MOTH_INSTR_HEADER
+        Param arg;
+    };
+    struct instr_callBuiltinPopScope {
+        MOTH_INSTR_HEADER
+    };
+    struct instr_callBuiltinForeachIteratorObject {
+        MOTH_INSTR_HEADER
+        Param arg;
+        Param result;
+    };
+    struct instr_callBuiltinForeachNextPropertyName {
+        MOTH_INSTR_HEADER
+        Param arg;
+        Param result;
+    };
+    struct instr_callBuiltinDeleteMember {
+        MOTH_INSTR_HEADER
+        VM::String *member;
+        Param base;
+        Param result;
+    };
+    struct instr_callBuiltinDeleteSubscript {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param result;
+    };
+    struct instr_callBuiltinDeleteName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param result;
+    };
+    struct instr_callBuiltinTypeofMember {
+        MOTH_INSTR_HEADER
+        VM::String *member;
+        Param base;
+        Param result;
+    };
+    struct instr_callBuiltinTypeofSubscript {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param result;
+    };
+    struct instr_callBuiltinTypeofName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param result;
+    };
+    struct instr_callBuiltinTypeofValue {
+        MOTH_INSTR_HEADER
+        Param value;
+        Param result;
+    };
+    struct instr_callBuiltinPostIncMember {
+        MOTH_INSTR_HEADER
+        Param base;
+        VM::String *member;
+        Param result;
+    };
+    struct instr_callBuiltinPostIncSubscript {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param result;
+    };
+    struct instr_callBuiltinPostIncName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param result;
+    };
+    struct instr_callBuiltinPostIncValue {
+        MOTH_INSTR_HEADER
+        Param value;
+        Param result;
+    };
+    struct instr_callBuiltinPostDecMember {
+        MOTH_INSTR_HEADER
+        Param base;
+        VM::String *member;
+        Param result;
+    };
+    struct instr_callBuiltinPostDecSubscript {
+        MOTH_INSTR_HEADER
+        Param base;
+        Param index;
+        Param result;
+    };
+    struct instr_callBuiltinPostDecName {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param result;
+    };
+    struct instr_callBuiltinPostDecValue {
+        MOTH_INSTR_HEADER
+        Param value;
+        Param result;
+    };
+    struct instr_callBuiltinDeclareVar {
+        MOTH_INSTR_HEADER
+        VM::String *varName;
+        bool isDeletable;
+    };
+    struct instr_callBuiltinDefineGetterSetter {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param object;
+        Param getter;
+        Param setter;
+    };
+    struct instr_callBuiltinDefineProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        Param object;
+        Param value;
+    };
+    struct instr_callBuiltinDefineArray {
+        MOTH_INSTR_HEADER
+        quint32 argc;
+        quint32 args;
+        Param result;
+    };
+    struct instr_createValue {
+        MOTH_INSTR_HEADER
+        quint32 argc;
+        quint32 args;
+        Param func;
+        Param result;
+    };
+    struct instr_createProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        quint32 argc;
+        quint32 args;
+        Param base;
+        Param result;
+    };
+    struct instr_createActivationProperty {
+        MOTH_INSTR_HEADER
+        VM::String *name;
+        quint32 argc;
+        quint32 args;
+        Param result;
+    };
+    struct instr_jump {
+        MOTH_INSTR_HEADER
+        ptrdiff_t offset; 
+    };
+    struct instr_cjump {
+        MOTH_INSTR_HEADER
+        ptrdiff_t offset;
+        Param condition;
+    };
+    struct instr_unop {
+        MOTH_INSTR_HEADER
+        VM::UnaryOpName alu;
+        Param source;
+        Param result;
+    };
+    struct instr_binop {
+        MOTH_INSTR_HEADER
+        VM::BinOp alu;
+        Param lhs;
+        Param rhs;
+        Param result;
+    };
+    struct instr_loadThis {
+        MOTH_INSTR_HEADER
+        Param result;
+    };
+    struct instr_inplaceElementOp {
+        MOTH_INSTR_HEADER
+        VM::InplaceBinOpElement alu;
+        Param base;
+        Param index;
+        Param source;
+    };
+    struct instr_inplaceMemberOp {
+        MOTH_INSTR_HEADER
+        VM::InplaceBinOpMember alu;
+        VM::String *member;
+        Param base;
+        Param source;
+    };
+    struct instr_inplaceNameOp {
+        MOTH_INSTR_HEADER
+        VM::InplaceBinOpName alu;
+        VM::String *name;
+        Param source;
+    };
+
+    instr_common common;
+    instr_ret ret;
+    instr_loadValue loadValue;
+    instr_moveTemp moveTemp;
+    instr_loadClosure loadClosure;
+    instr_loadName loadName;
+    instr_storeName storeName;
+    instr_loadElement loadElement;
+    instr_storeElement storeElement;
+    instr_loadProperty loadProperty;
+    instr_storeProperty storeProperty;
+    instr_push push;
+    instr_enterTry enterTry;
+    instr_callValue callValue;
+    instr_callProperty callProperty;
+    instr_callElement callElement;
+    instr_callActivationProperty callActivationProperty;
+    instr_callBuiltinThrow callBuiltinThrow;
+    instr_callBuiltinFinishTry callBuiltinFinishTry;
+    instr_callBuiltinPushScope callBuiltinPushScope;
+    instr_callBuiltinPopScope callBuiltinPopScope;
+    instr_callBuiltinForeachIteratorObject callBuiltinForeachIteratorObject;
+    instr_callBuiltinForeachNextPropertyName callBuiltinForeachNextPropertyName;
+    instr_callBuiltinDeleteMember callBuiltinDeleteMember;
+    instr_callBuiltinDeleteSubscript callBuiltinDeleteSubscript;
+    instr_callBuiltinDeleteName callBuiltinDeleteName;
+    instr_callBuiltinTypeofMember callBuiltinTypeofMember;
+    instr_callBuiltinTypeofSubscript callBuiltinTypeofSubscript;
+    instr_callBuiltinTypeofName callBuiltinTypeofName;
+    instr_callBuiltinTypeofValue callBuiltinTypeofValue;
+    instr_callBuiltinPostIncMember callBuiltinPostIncMember;
+    instr_callBuiltinPostIncSubscript callBuiltinPostIncSubscript;
+    instr_callBuiltinPostIncName callBuiltinPostIncName;
+    instr_callBuiltinPostIncValue callBuiltinPostIncValue;
+    instr_callBuiltinPostDecMember callBuiltinPostDecMember;
+    instr_callBuiltinPostDecSubscript callBuiltinPostDecSubscript;
+    instr_callBuiltinPostDecName callBuiltinPostDecName;
+    instr_callBuiltinPostDecValue callBuiltinPostDecValue;
+    instr_callBuiltinDeclareVar callBuiltinDeclareVar;
+    instr_callBuiltinDefineGetterSetter callBuiltinDefineGetterSetter;
+    instr_callBuiltinDefineProperty callBuiltinDefineProperty;
+    instr_callBuiltinDefineArray callBuiltinDefineArray;
+    instr_createValue createValue;
+    instr_createProperty createProperty;
+    instr_createActivationProperty createActivationProperty;
+    instr_jump jump;
+    instr_cjump cjump;
+    instr_unop unop;
+    instr_binop binop;
+    instr_loadThis loadThis;
+    instr_inplaceElementOp inplaceElementOp;
+    instr_inplaceMemberOp inplaceMemberOp;
+    instr_inplaceNameOp inplaceNameOp;
+
+    static int size(Type type);
+};
+
+template<int N>
+struct InstrMeta {
+};
+
+#define MOTH_INSTR_META_TEMPLATE(I, FMT) \
+    template<> struct InstrMeta<(int)Instr::I> { \
+        enum { Size = MOTH_INSTR_SIZE(I, FMT) }; \
+        typedef Instr::instr_##FMT DataType; \
+        static const DataType &data(const Instr &instr) { return instr.FMT; } \
+        static void setData(Instr &instr, const DataType &v) { instr.FMT = v; } \
+    }; 
+FOR_EACH_MOTH_INSTR(MOTH_INSTR_META_TEMPLATE);
+#undef MOTH_INSTR_META_TEMPLATE
+
+template<int InstrType>
+class InstrData : public InstrMeta<InstrType>::DataType
+{
+};
+
+} // namespace Moth
+} // namespace QQmlJS
+
+#endif // QV4INSTR_MOTH_P_H
diff --git a/src/qml/qml/v4vm/moth/qv4isel_moth.cpp b/src/qml/qml/v4vm/moth/qv4isel_moth.cpp
new file mode 100644
index 0000000000..00ae4e1029
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4isel_moth.cpp
@@ -0,0 +1,812 @@
+#include "qv4isel_util_p.h"
+#include "qv4isel_moth_p.h"
+#include "qv4vme_moth_p.h"
+#include "qv4functionobject.h"
+#include "qv4regexpobject.h"
+#include "debugging.h"
+
+using namespace QQmlJS;
+using namespace QQmlJS::Moth;
+
+namespace {
+
+inline VM::BinOp aluOpFunction(V4IR::AluOp op)
+{
+    switch (op) {
+    case V4IR::OpInvalid:
+        return 0;
+    case V4IR::OpIfTrue:
+        return 0;
+    case V4IR::OpNot:
+        return 0;
+    case V4IR::OpUMinus:
+        return 0;
+    case V4IR::OpUPlus:
+        return 0;
+    case V4IR::OpCompl:
+        return 0;
+    case V4IR::OpBitAnd:
+        return VM::__qmljs_bit_and;
+    case V4IR::OpBitOr:
+        return VM::__qmljs_bit_or;
+    case V4IR::OpBitXor:
+        return VM::__qmljs_bit_xor;
+    case V4IR::OpAdd:
+        return VM::__qmljs_add;
+    case V4IR::OpSub:
+        return VM::__qmljs_sub;
+    case V4IR::OpMul:
+        return VM::__qmljs_mul;
+    case V4IR::OpDiv:
+        return VM::__qmljs_div;
+    case V4IR::OpMod:
+        return VM::__qmljs_mod;
+    case V4IR::OpLShift:
+        return VM::__qmljs_shl;
+    case V4IR::OpRShift:
+        return VM::__qmljs_shr;
+    case V4IR::OpURShift:
+        return VM::__qmljs_ushr;
+    case V4IR::OpGt:
+        return VM::__qmljs_gt;
+    case V4IR::OpLt:
+        return VM::__qmljs_lt;
+    case V4IR::OpGe:
+        return VM::__qmljs_ge;
+    case V4IR::OpLe:
+        return VM::__qmljs_le;
+    case V4IR::OpEqual:
+        return VM::__qmljs_eq;
+    case V4IR::OpNotEqual:
+        return VM::__qmljs_ne;
+    case V4IR::OpStrictEqual:
+        return VM::__qmljs_se;
+    case V4IR::OpStrictNotEqual:
+        return VM::__qmljs_sne;
+    case V4IR::OpInstanceof:
+        return VM::__qmljs_instanceof;
+    case V4IR::OpIn:
+        return VM::__qmljs_in;
+    case V4IR::OpAnd:
+        return 0;
+    case V4IR::OpOr:
+        return 0;
+    default:
+        assert(!"Unknown AluOp");
+        return 0;
+    }
+};
+
+} // anonymous namespace
+
+InstructionSelection::InstructionSelection(VM::ExecutionEngine *engine, V4IR::Module *module)
+    : EvalInstructionSelection(engine, module)
+    , _function(0)
+    , _vmFunction(0)
+    , _block(0)
+    , _codeStart(0)
+    , _codeNext(0)
+    , _codeEnd(0)
+{
+}
+
+InstructionSelection::~InstructionSelection()
+{
+}
+
+void InstructionSelection::run(VM::Function *vmFunction, V4IR::Function *function)
+{
+    V4IR::BasicBlock *block;
+
+    QHash<V4IR::BasicBlock *, QVector<ptrdiff_t> > patches;
+    QHash<V4IR::BasicBlock *, ptrdiff_t> addrs;
+
+    int codeSize = 4096;
+    uchar *codeStart = new uchar[codeSize];
+    uchar *codeNext = codeStart;
+    uchar *codeEnd = codeStart + codeSize;
+
+    qSwap(_function, function);
+    qSwap(_vmFunction, vmFunction);
+    qSwap(block, _block);
+    qSwap(patches, _patches);
+    qSwap(addrs, _addrs);
+    qSwap(codeStart, _codeStart);
+    qSwap(codeNext, _codeNext);
+    qSwap(codeEnd, _codeEnd);
+
+    int locals = frameSize();
+    assert(locals >= 0);
+
+    Instruction::Push push;
+    push.value = quint32(locals);
+    addInstruction(push);
+
+    foreach (_block, _function->basicBlocks) {
+        _addrs.insert(_block, _codeNext - _codeStart);
+
+        foreach (V4IR::Stmt *s, _block->statements)
+            s->accept(this);
+    }
+
+    patchJumpAddresses();
+
+    _vmFunction->code = VME::exec;
+    _vmFunction->codeData = squeezeCode();
+
+    qSwap(_function, function);
+    qSwap(_vmFunction, vmFunction);
+    qSwap(block, _block);
+    qSwap(patches, _patches);
+    qSwap(addrs, _addrs);
+    qSwap(codeStart, _codeStart);
+    qSwap(codeNext, _codeNext);
+    qSwap(codeEnd, _codeEnd);
+
+    delete[] codeStart;
+}
+
+void InstructionSelection::callValue(V4IR::Temp *value, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    Instruction::CallValue call;
+    prepareCallArgs(args, call.argc, call.args);
+    call.dest = getParam(value);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callProperty(V4IR::Temp *base, const QString &name, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    // call the property on the loaded base
+    Instruction::CallProperty call;
+    call.base = getParam(base);
+    call.name = identifier(name);
+    prepareCallArgs(args, call.argc, call.args);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    // call the property on the loaded base
+    Instruction::CallElement call;
+    call.base = getParam(base);
+    call.index = getParam(index);
+    prepareCallArgs(args, call.argc, call.args);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::constructActivationProperty(V4IR::Name *func,
+                                                       V4IR::ExprList *args,
+                                                       V4IR::Temp *result)
+{
+    Instruction::CreateActivationProperty create;
+    create.name = identifier(*func->id);
+    prepareCallArgs(args, create.argc, create.args);
+    create.result = getResultParam(result);
+    addInstruction(create);
+}
+
+void InstructionSelection::constructProperty(V4IR::Temp *base, const QString &name, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    Instruction::CreateProperty create;
+    create.base = getParam(base);
+    create.name = identifier(name);
+    prepareCallArgs(args, create.argc, create.args);
+    create.result = getResultParam(result);
+    addInstruction(create);
+}
+
+void InstructionSelection::constructValue(V4IR::Temp *value, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    Instruction::CreateValue create;
+    create.func = getParam(value);
+    prepareCallArgs(args, create.argc, create.args);
+    create.result = getResultParam(result);
+    addInstruction(create);
+}
+
+void InstructionSelection::loadThisObject(V4IR::Temp *temp)
+{
+    Instruction::LoadThis load;
+    load.result = getResultParam(temp);
+    addInstruction(load);
+}
+
+void InstructionSelection::loadConst(V4IR::Const *sourceConst, V4IR::Temp *targetTemp)
+{
+    assert(sourceConst);
+
+    Instruction::LoadValue load;
+    load.value = getParam(sourceConst);
+    load.result = getResultParam(targetTemp);
+    addInstruction(load);
+}
+
+void InstructionSelection::loadString(const QString &str, V4IR::Temp *targetTemp)
+{
+    Instruction::LoadValue load;
+    load.value = Instr::Param::createValue(VM::Value::fromString(identifier(str)));
+    load.result = getResultParam(targetTemp);
+    addInstruction(load);
+}
+
+void InstructionSelection::loadRegexp(V4IR::RegExp *sourceRegexp, V4IR::Temp *targetTemp)
+{
+    VM::Value v = VM::Value::fromObject(engine()->newRegExpObject(
+                                            *sourceRegexp->value,
+                                            sourceRegexp->flags));
+    _vmFunction->generatedValues.append(v);
+
+    Instruction::LoadValue load;
+    load.value = Instr::Param::createValue(v);
+    load.result = getResultParam(targetTemp);
+    addInstruction(load);
+}
+
+void InstructionSelection::getActivationProperty(const V4IR::Name *name, V4IR::Temp *temp)
+{
+    Instruction::LoadName load;
+    load.name = identifier(*name->id);
+    load.result = getResultParam(temp);
+    addInstruction(load);
+}
+
+void InstructionSelection::setActivationProperty(V4IR::Temp *source, const QString &targetName)
+{
+    Instruction::StoreName store;
+    store.source = getParam(source);
+    store.name = identifier(targetName);
+    addInstruction(store);
+}
+
+void InstructionSelection::initClosure(V4IR::Closure *closure, V4IR::Temp *target)
+{
+    VM::Function *vmFunc = vmFunction(closure->value);
+    assert(vmFunc);
+    Instruction::LoadClosure load;
+    load.value = vmFunc;
+    load.result = getResultParam(target);
+    addInstruction(load);
+}
+
+void InstructionSelection::getProperty(V4IR::Temp *base, const QString &name, V4IR::Temp *target)
+{
+    Instruction::LoadProperty load;
+    load.base = getParam(base);
+    load.name = identifier(name);
+    load.result = getResultParam(target);
+    addInstruction(load);
+}
+
+void InstructionSelection::setProperty(V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName)
+{
+    Instruction::StoreProperty store;
+    store.base = getParam(targetBase);
+    store.name = identifier(targetName);
+    store.source = getParam(source);
+    addInstruction(store);
+}
+
+void InstructionSelection::getElement(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *target)
+{
+    Instruction::LoadElement load;
+    load.base = getParam(base);
+    load.index = getParam(index);
+    load.result = getResultParam(target);
+    addInstruction(load);
+}
+
+void InstructionSelection::setElement(V4IR::Temp *source, V4IR::Temp *targetBase, V4IR::Temp *targetIndex)
+{
+    Instruction::StoreElement store;
+    store.base = getParam(targetBase);
+    store.index = getParam(targetIndex);
+    store.source = getParam(source);
+    addInstruction(store);
+}
+
+void InstructionSelection::copyValue(V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp)
+{
+    Instruction::MoveTemp move;
+    move.source = getParam(sourceTemp);
+    move.result = getResultParam(targetTemp);
+    addInstruction(move);
+}
+
+void InstructionSelection::unop(V4IR::AluOp oper, V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp)
+{
+    VM::UnaryOpName op = 0;
+    switch (oper) {
+    case V4IR::OpIfTrue: assert(!"unreachable"); break;
+    case V4IR::OpNot: op = VM::__qmljs_not; break;
+    case V4IR::OpUMinus: op = VM::__qmljs_uminus; break;
+    case V4IR::OpUPlus: op = VM::__qmljs_uplus; break;
+    case V4IR::OpCompl: op = VM::__qmljs_compl; break;
+    case V4IR::OpIncrement: op = VM::__qmljs_increment; break;
+    case V4IR::OpDecrement: op = VM::__qmljs_decrement; break;
+    default: assert(!"unreachable"); break;
+    } // switch
+
+    if (op) {
+        Instruction::Unop unop;
+        unop.alu = op;
+        unop.source = getParam(sourceTemp);
+        unop.result = getResultParam(targetTemp);
+        addInstruction(unop);
+    } else {
+        qWarning("  UNOP1");
+    }
+}
+
+void InstructionSelection::binop(V4IR::AluOp oper, V4IR::Temp *leftSource, V4IR::Temp *rightSource, V4IR::Temp *target)
+{
+    Instruction::Binop binop;
+    binop.alu = aluOpFunction(oper);
+    binop.lhs = getParam(leftSource);
+    binop.rhs = getParam(rightSource);
+    binop.result = getResultParam(target);
+    addInstruction(binop);
+}
+
+void InstructionSelection::inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName)
+{
+    VM::InplaceBinOpName op = 0;
+    switch (oper) {
+    case V4IR::OpBitAnd: op = VM::__qmljs_inplace_bit_and_name; break;
+    case V4IR::OpBitOr: op = VM::__qmljs_inplace_bit_or_name; break;
+    case V4IR::OpBitXor: op = VM::__qmljs_inplace_bit_xor_name; break;
+    case V4IR::OpAdd: op = VM::__qmljs_inplace_add_name; break;
+    case V4IR::OpSub: op = VM::__qmljs_inplace_sub_name; break;
+    case V4IR::OpMul: op = VM::__qmljs_inplace_mul_name; break;
+    case V4IR::OpDiv: op = VM::__qmljs_inplace_div_name; break;
+    case V4IR::OpMod: op = VM::__qmljs_inplace_mod_name; break;
+    case V4IR::OpLShift: op = VM::__qmljs_inplace_shl_name; break;
+    case V4IR::OpRShift: op = VM::__qmljs_inplace_shr_name; break;
+    case V4IR::OpURShift: op = VM::__qmljs_inplace_ushr_name; break;
+    default: break;
+    }
+
+    if (op) {
+        Instruction::InplaceNameOp ieo;
+        ieo.alu = op;
+        ieo.name = identifier(targetName);
+        ieo.source = getParam(rightSource);
+        addInstruction(ieo);
+    }
+}
+
+void InstructionSelection::inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp)
+{
+    VM::InplaceBinOpElement op = 0;
+    switch (oper) {
+    case V4IR::OpBitAnd: op = VM::__qmljs_inplace_bit_and_element; break;
+    case V4IR::OpBitOr: op = VM::__qmljs_inplace_bit_or_element; break;
+    case V4IR::OpBitXor: op = VM::__qmljs_inplace_bit_xor_element; break;
+    case V4IR::OpAdd: op = VM::__qmljs_inplace_add_element; break;
+    case V4IR::OpSub: op = VM::__qmljs_inplace_sub_element; break;
+    case V4IR::OpMul: op = VM::__qmljs_inplace_mul_element; break;
+    case V4IR::OpDiv: op = VM::__qmljs_inplace_div_element; break;
+    case V4IR::OpMod: op = VM::__qmljs_inplace_mod_element; break;
+    case V4IR::OpLShift: op = VM::__qmljs_inplace_shl_element; break;
+    case V4IR::OpRShift: op = VM::__qmljs_inplace_shr_element; break;
+    case V4IR::OpURShift: op = VM::__qmljs_inplace_ushr_element; break;
+    default: break;
+    }
+
+    Instruction::InplaceElementOp ieo;
+    ieo.alu = op;
+    ieo.base = getParam(targetBaseTemp);
+    ieo.index = getParam(targetIndexTemp);
+    ieo.source = getParam(source);
+    addInstruction(ieo);
+}
+
+void InstructionSelection::inplaceMemberOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName)
+{
+    VM::InplaceBinOpMember op = 0;
+    switch (oper) {
+    case V4IR::OpBitAnd: op = VM::__qmljs_inplace_bit_and_member; break;
+    case V4IR::OpBitOr: op = VM::__qmljs_inplace_bit_or_member; break;
+    case V4IR::OpBitXor: op = VM::__qmljs_inplace_bit_xor_member; break;
+    case V4IR::OpAdd: op = VM::__qmljs_inplace_add_member; break;
+    case V4IR::OpSub: op = VM::__qmljs_inplace_sub_member; break;
+    case V4IR::OpMul: op = VM::__qmljs_inplace_mul_member; break;
+    case V4IR::OpDiv: op = VM::__qmljs_inplace_div_member; break;
+    case V4IR::OpMod: op = VM::__qmljs_inplace_mod_member; break;
+    case V4IR::OpLShift: op = VM::__qmljs_inplace_shl_member; break;
+    case V4IR::OpRShift: op = VM::__qmljs_inplace_shr_member; break;
+    case V4IR::OpURShift: op = VM::__qmljs_inplace_ushr_member; break;
+    default: break;
+    }
+
+    Instruction::InplaceMemberOp imo;
+    imo.alu = op;
+    imo.base = getParam(targetBase);
+    imo.member = identifier(targetName);
+    imo.source = getParam(source);
+    addInstruction(imo);
+}
+
+void InstructionSelection::prepareCallArgs(V4IR::ExprList *e, quint32 &argc, quint32 &args)
+{
+    bool singleArgIsTemp = false;
+    if (e && e->next == 0 && e->expr->asTemp()) {
+        // ok, only 1 argument in the call...
+        const int idx = e->expr->asTemp()->index;
+        // We can only pass a reference into the stack, which holds temps that
+        // are not arguments (idx >= 0) nor locals (idx >= localCound).
+        singleArgIsTemp = idx >= _function->locals.size() && e->expr->asTemp()->scope == 0;
+    }
+
+    if (singleArgIsTemp) {
+        // We pass single arguments as references to the stack, but only if it's not a local or an argument.
+        argc = 1;
+        args = e->expr->asTemp()->index - _function->locals.size();
+    } else if (e) {
+        // We need to move all the temps into the function arg array
+        int argLocation = outgoingArgumentTempStart();
+        assert(argLocation >= 0);
+        argc = 0;
+        args = argLocation;
+        while (e) {
+            Instruction::MoveTemp move;
+            move.source = getParam(e->expr);
+            move.result = Instr::Param::createTemp(argLocation);
+            addInstruction(move);
+            ++argLocation;
+            ++argc;
+            e = e->next;
+        }
+    } else {
+        argc = 0;
+        args = 0;
+    }
+}
+
+void InstructionSelection::visitJump(V4IR::Jump *s)
+{
+    Instruction::Jump jump;
+    jump.offset = 0;
+    ptrdiff_t loc = addInstruction(jump) + (((const char *)&jump.offset) - ((const char *)&jump));
+
+    _patches[s->target].append(loc);
+}
+
+void InstructionSelection::visitCJump(V4IR::CJump *s)
+{
+    Instr::Param condition;
+    if (V4IR::Temp *t = s->cond->asTemp()) {
+        condition = getResultParam(t);
+    } else if (V4IR::Binop *b = s->cond->asBinop()) {
+        condition = getResultParam(0);
+        Instruction::Binop binop;
+        binop.alu = aluOpFunction(b->op);
+        binop.lhs = getParam(b->left);
+        binop.rhs = getParam(b->right);
+        binop.result = condition;
+        addInstruction(binop);
+    } else {
+        Q_UNIMPLEMENTED();
+    }
+
+    Instruction::CJump jump;
+    jump.offset = 0;
+    jump.condition = condition;
+    ptrdiff_t trueLoc = addInstruction(jump) + (((const char *)&jump.offset) - ((const char *)&jump));
+    _patches[s->iftrue].append(trueLoc);
+
+    if (_block->index + 1 != s->iffalse->index) {
+        Instruction::Jump jump;
+        jump.offset = 0;
+        ptrdiff_t falseLoc = addInstruction(jump) + (((const char *)&jump.offset) - ((const char *)&jump));
+        _patches[s->iffalse].append(falseLoc);
+    }
+}
+
+void InstructionSelection::visitRet(V4IR::Ret *s)
+{
+    Instruction::Ret ret;
+    ret.result = getParam(s->expr);
+    addInstruction(ret);
+}
+
+void InstructionSelection::visitTry(V4IR::Try *t)
+{
+    Instruction::EnterTry enterTry;
+    enterTry.tryOffset = 0;
+    enterTry.catchOffset = 0;
+    enterTry.exceptionVarName = identifier(t->exceptionVarName);
+    enterTry.exceptionVar = getParam(t->exceptionVar);
+    ptrdiff_t enterTryLoc = addInstruction(enterTry);
+
+    ptrdiff_t tryLoc = enterTryLoc + (((const char *)&enterTry.tryOffset) - ((const char *)&enterTry));
+    _patches[t->tryBlock].append(tryLoc);
+
+    ptrdiff_t catchLoc = enterTryLoc + (((const char *)&enterTry.catchOffset) - ((const char *)&enterTry));
+    _patches[t->catchBlock].append(catchLoc);
+}
+
+void InstructionSelection::callBuiltinInvalid(V4IR::Name *func, V4IR::ExprList *args, V4IR::Temp *result)
+{
+    Instruction::CallActivationProperty call;
+    call.name = identifier(*func->id);
+    prepareCallArgs(args, call.argc, call.args);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinTypeofMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinTypeofMember call;
+    call.base = getParam(base);
+    call.member = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinTypeofSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinTypeofSubscript call;
+    call.base = getParam(base);
+    call.index = getParam(index);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinTypeofName(const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinTypeofName call;
+    call.name = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinTypeofValue(V4IR::Temp *value, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinTypeofValue call;
+    call.value = getParam(value);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDeleteMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinDeleteMember call;
+    call.base = getParam(base);
+    call.member = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDeleteSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinDeleteSubscript call;
+    call.base = getParam(base);
+    call.index = getParam(index);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDeleteName(const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinDeleteName call;
+    call.name = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDeleteValue(V4IR::Temp *result)
+{
+    Instruction::LoadValue load;
+    load.value = Instr::Param::createValue(VM::Value::fromBoolean(false));
+    load.result = getResultParam(result);
+    addInstruction(load);
+}
+
+void InstructionSelection::callBuiltinPostDecrementMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostDecMember call;
+    call.base = getParam(base);
+    call.member = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostDecrementSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostDecSubscript call;
+    call.base = getParam(base);
+    call.index = getParam(index);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostDecrementName(const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostDecName call;
+    call.name = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostDecrementValue(V4IR::Temp *value, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostDecValue call;
+    call.value = getParam(value);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostIncrementMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostIncMember call;
+    call.base = getParam(base);
+    call.member = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostIncrementSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostIncSubscript call;
+    call.base = getParam(base);
+    call.index = getParam(index);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostIncrementName(const QString &name, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostIncName call;
+    call.name = identifier(name);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPostIncrementValue(V4IR::Temp *value, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinPostIncValue call;
+    call.value = getParam(value);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinThrow(V4IR::Temp *arg)
+{
+    Instruction::CallBuiltinThrow call;
+    call.arg = getParam(arg);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinFinishTry()
+{
+    Instruction::CallBuiltinFinishTry call;
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinForeachIteratorObject(V4IR::Temp *arg, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinForeachIteratorObject call;
+    call.arg = getParam(arg);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinForeachNextPropertyname(V4IR::Temp *arg, V4IR::Temp *result)
+{
+    Instruction::CallBuiltinForeachNextPropertyName call;
+    call.arg = getParam(arg);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPushWithScope(V4IR::Temp *arg)
+{
+    Instruction::CallBuiltinPushScope call;
+    call.arg = getParam(arg);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinPopScope()
+{
+    Instruction::CallBuiltinPopScope call;
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDeclareVar(bool deletable, const QString &name)
+{
+    Instruction::CallBuiltinDeclareVar call;
+    call.isDeletable = deletable;
+    call.varName = identifier(name);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDefineGetterSetter(V4IR::Temp *object, const QString &name, V4IR::Temp *getter, V4IR::Temp *setter)
+{
+    Instruction::CallBuiltinDefineGetterSetter call;
+    call.object = getParam(object);
+    call.name = identifier(name);
+    call.getter = getParam(getter);
+    call.setter = getParam(setter);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDefineProperty(V4IR::Temp *object, const QString &name, V4IR::Temp *value)
+{
+    Instruction::CallBuiltinDefineProperty call;
+    call.object = getParam(object);
+    call.name = identifier(name);
+    call.value = getParam(value);
+    addInstruction(call);
+}
+
+void InstructionSelection::callBuiltinDefineArray(V4IR::Temp *result, V4IR::ExprList *args)
+{
+    Instruction::CallBuiltinDefineArray call;
+    prepareCallArgs(args, call.argc, call.args);
+    call.result = getResultParam(result);
+    addInstruction(call);
+}
+
+ptrdiff_t InstructionSelection::addInstructionHelper(Instr::Type type, Instr &instr)
+{
+#ifdef MOTH_THREADED_INTERPRETER
+    instr.common.code = VME::instructionJumpTable()[static_cast<int>(type)];
+#else
+    instr.common.instructionType = type;
+#endif
+
+    int instructionSize = Instr::size(type);
+    if (_codeEnd - _codeNext < instructionSize) {
+        int currSize = _codeEnd - _codeStart;
+        uchar *newCode = new uchar[currSize * 2];
+        ::memset(newCode + currSize, 0, currSize);
+        ::memcpy(newCode, _codeStart, currSize);
+        _codeNext = _codeNext - _codeStart + newCode;
+        delete[] _codeStart;
+        _codeStart = newCode;
+        _codeEnd = _codeStart + currSize * 2;
+    }
+
+    ::memcpy(_codeNext, reinterpret_cast<const char *>(&instr), instructionSize);
+    ptrdiff_t ptrOffset = _codeNext - _codeStart;
+    _codeNext += instructionSize;
+
+    return ptrOffset;
+}
+
+void InstructionSelection::patchJumpAddresses()
+{
+    typedef QHash<V4IR::BasicBlock *, QVector<ptrdiff_t> >::ConstIterator PatchIt;
+    for (PatchIt i = _patches.begin(), ei = _patches.end(); i != ei; ++i) {
+        Q_ASSERT(_addrs.contains(i.key()));
+        ptrdiff_t target = _addrs.value(i.key());
+
+        const QVector<ptrdiff_t> &patchList = i.value();
+        for (int ii = 0, eii = patchList.count(); ii < eii; ++ii) {
+            ptrdiff_t patch = patchList.at(ii);
+
+            *((ptrdiff_t *)(_codeStart + patch)) = target - patch;
+        }
+    }
+
+    _patches.clear();
+    _addrs.clear();
+}
+
+uchar *InstructionSelection::squeezeCode() const
+{
+    int codeSize = _codeNext - _codeStart;
+    uchar *squeezed = new uchar[codeSize];
+    ::memcpy(squeezed, _codeStart, codeSize);
+    return squeezed;
+}
+
+VM::String *InstructionSelection::identifier(const QString &s)
+{
+    VM::String *str = engine()->newIdentifier(s);
+    _vmFunction->identifiers.append(str);
+    return str;
+}
diff --git a/src/qml/qml/v4vm/moth/qv4isel_moth_p.h b/src/qml/qml/v4vm/moth/qv4isel_moth_p.h
new file mode 100644
index 0000000000..5e057139e2
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4isel_moth_p.h
@@ -0,0 +1,169 @@
+#ifndef QV4ISEL_MOTH_P_H
+#define QV4ISEL_MOTH_P_H
+
+#include "qv4global.h"
+#include "qv4isel_p.h"
+#include "qv4jsir_p.h"
+#include "qv4object.h"
+#include "qv4instr_moth_p.h"
+
+namespace QQmlJS {
+namespace Moth {
+
+class Q_V4_EXPORT InstructionSelection:
+        public V4IR::InstructionSelection,
+        public EvalInstructionSelection
+{
+public:
+    InstructionSelection(VM::ExecutionEngine *engine, V4IR::Module *module);
+    ~InstructionSelection();
+
+    virtual void run(VM::Function *vmFunction, V4IR::Function *function);
+
+protected:
+    virtual void visitJump(V4IR::Jump *);
+    virtual void visitCJump(V4IR::CJump *);
+    virtual void visitRet(V4IR::Ret *);
+    virtual void visitTry(V4IR::Try *);
+
+    virtual void callBuiltinInvalid(V4IR::Name *func, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void callBuiltinTypeofMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinTypeofSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result);
+    virtual void callBuiltinTypeofName(const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinTypeofValue(V4IR::Temp *value, V4IR::Temp *result);
+    virtual void callBuiltinDeleteMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinDeleteSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result);
+    virtual void callBuiltinDeleteName(const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinDeleteValue(V4IR::Temp *result);
+    virtual void callBuiltinPostDecrementMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinPostDecrementSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result);
+    virtual void callBuiltinPostDecrementName(const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinPostDecrementValue(V4IR::Temp *value, V4IR::Temp *result);
+    virtual void callBuiltinPostIncrementMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinPostIncrementSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result);
+    virtual void callBuiltinPostIncrementName(const QString &name, V4IR::Temp *result);
+    virtual void callBuiltinPostIncrementValue(V4IR::Temp *value, V4IR::Temp *result);
+    virtual void callBuiltinThrow(V4IR::Temp *arg);
+    virtual void callBuiltinFinishTry();
+    virtual void callBuiltinForeachIteratorObject(V4IR::Temp *arg, V4IR::Temp *result);
+    virtual void callBuiltinForeachNextPropertyname(V4IR::Temp *arg, V4IR::Temp *result);
+    virtual void callBuiltinPushWithScope(V4IR::Temp *arg);
+    virtual void callBuiltinPopScope();
+    virtual void callBuiltinDeclareVar(bool deletable, const QString &name);
+    virtual void callBuiltinDefineGetterSetter(V4IR::Temp *object, const QString &name, V4IR::Temp *getter, V4IR::Temp *setter);
+    virtual void callBuiltinDefineProperty(V4IR::Temp *object, const QString &name, V4IR::Temp *value);
+    virtual void callBuiltinDefineArray(V4IR::Temp *result, V4IR::ExprList *args);
+    virtual void callValue(V4IR::Temp *value, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void callProperty(V4IR::Temp *base, const QString &name, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void callSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void constructActivationProperty(V4IR::Name *func, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void constructProperty(V4IR::Temp *base, const QString &name, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void constructValue(V4IR::Temp *value, V4IR::ExprList *args, V4IR::Temp *result);
+    virtual void loadThisObject(V4IR::Temp *temp);
+    virtual void loadConst(V4IR::Const *sourceConst, V4IR::Temp *targetTemp);
+    virtual void loadString(const QString &str, V4IR::Temp *targetTemp);
+    virtual void loadRegexp(V4IR::RegExp *sourceRegexp, V4IR::Temp *targetTemp);
+    virtual void getActivationProperty(const V4IR::Name *name, V4IR::Temp *temp);
+    virtual void setActivationProperty(V4IR::Temp *source, const QString &targetName);
+    virtual void initClosure(V4IR::Closure *closure, V4IR::Temp *target);
+    virtual void getProperty(V4IR::Temp *base, const QString &name, V4IR::Temp *target);
+    virtual void setProperty(V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName);
+    virtual void getElement(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *target);
+    virtual void setElement(V4IR::Temp *source, V4IR::Temp *targetBase, V4IR::Temp *targetIndex);
+    virtual void copyValue(V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp);
+    virtual void unop(V4IR::AluOp oper, V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp);
+    virtual void binop(V4IR::AluOp oper, V4IR::Temp *leftSource, V4IR::Temp *rightSource, V4IR::Temp *target);
+    virtual void inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName);
+    virtual void inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp);
+    virtual void inplaceMemberOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName);
+
+private:
+    struct Instruction {
+#define MOTH_INSTR_DATA_TYPEDEF(I, FMT) typedef InstrData<Instr::I> I;
+    FOR_EACH_MOTH_INSTR(MOTH_INSTR_DATA_TYPEDEF)
+#undef MOTH_INSTR_DATA_TYPEDEF
+    private:
+        Instruction();
+    };
+
+    Instr::Param getParam(V4IR::Expr *e)
+    {
+        typedef Instr::Param Param;
+        assert(e);
+
+        if (V4IR::Const *c = e->asConst()) {
+            return Param::createValue(convertToValue(c));
+        } else if (V4IR::Temp *t = e->asTemp()) {
+            const int index = t->index;
+            if (index < 0) {
+                return Param::createArgument(-index - 1, t->scope);
+            } else if (!t->scope) {
+                const int localCount = _function->locals.size();
+                if (index < localCount)
+                    return Param::createLocal(index);
+                else
+                    return Param::createTemp(index - localCount);
+            } else {
+                return Param::createScopedLocal(t->index, t->scope);
+            }
+        } else {
+            Q_UNIMPLEMENTED();
+            return Param();
+        }
+    }
+
+    Instr::Param getResultParam(V4IR::Temp *result)
+    {
+        if (result)
+            return getParam(result);
+        else
+            return Instr::Param::createTemp(scratchTempIndex());
+    }
+
+    void simpleMove(V4IR::Move *);
+    void prepareCallArgs(V4IR::ExprList *, quint32 &, quint32 &);
+
+    int outgoingArgumentTempStart() const { return _function->tempCount - _function->locals.size(); }
+    int scratchTempIndex() const { return outgoingArgumentTempStart() + _function->maxNumberOfArguments; }
+    int frameSize() const { return scratchTempIndex() + 1; }
+
+    template <int Instr>
+    inline ptrdiff_t addInstruction(const InstrData<Instr> &data);
+    ptrdiff_t addInstructionHelper(Instr::Type type, Instr &instr);
+    void patchJumpAddresses();
+    uchar *squeezeCode() const;
+
+    VM::String *identifier(const QString &s);
+
+    V4IR::Function *_function;
+    VM::Function *_vmFunction;
+    V4IR::BasicBlock *_block;
+
+    QHash<V4IR::BasicBlock *, QVector<ptrdiff_t> > _patches;
+    QHash<V4IR::BasicBlock *, ptrdiff_t> _addrs;
+
+    uchar *_codeStart;
+    uchar *_codeNext;
+    uchar *_codeEnd;
+};
+
+class Q_V4_EXPORT ISelFactory: public EvalISelFactory
+{
+public:
+    virtual ~ISelFactory() {}
+    virtual EvalInstructionSelection *create(VM::ExecutionEngine *engine, V4IR::Module *module)
+    { return new InstructionSelection(engine, module); }
+};
+
+template<int InstrT>
+ptrdiff_t InstructionSelection::addInstruction(const InstrData<InstrT> &data)
+{
+    Instr genericInstr;
+    InstrMeta<InstrT>::setData(genericInstr, data);
+    return addInstructionHelper(static_cast<Instr::Type>(InstrT), genericInstr);
+}
+
+} // namespace Moth
+} // namespace QQmlJS
+
+#endif // QV4ISEL_MOTH_P_H
diff --git a/src/qml/qml/v4vm/moth/qv4vme_moth.cpp b/src/qml/qml/v4vm/moth/qv4vme_moth.cpp
new file mode 100644
index 0000000000..a3c34bf340
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4vme_moth.cpp
@@ -0,0 +1,532 @@
+#include "qv4vme_moth_p.h"
+#include "qv4instr_moth_p.h"
+#include "qv4value.h"
+#include "debugging.h"
+
+#include <iostream>
+
+#include "qv4alloca_p.h"
+
+#ifdef DO_TRACE_INSTR
+#  define TRACE_INSTR(I) fprintf(stderr, "executing a %s\n", #I);
+#  define TRACE(n, str, ...) { char buf[4096]; snprintf(buf, 4096, str, __VA_ARGS__); fprintf(stderr, "    %s : %s\n", #n, buf); }
+#else
+#  define TRACE_INSTR(I)
+#  define TRACE(n, str, ...)
+#endif // DO_TRACE_INSTR
+
+using namespace QQmlJS;
+using namespace QQmlJS::Moth;
+
+class FunctionState: public Debugging::FunctionState
+{
+public:
+    FunctionState(QQmlJS::VM::ExecutionContext *context, const uchar **code)
+        : Debugging::FunctionState(context)
+        , stack(0)
+        , stackSize(0)
+        , code(code)
+    {}
+
+    virtual VM::Value *temp(unsigned idx) { return stack + idx; }
+
+    void setStack(VM::Value *stack, unsigned stackSize)
+    { this->stack = stack; this->stackSize = stackSize; }
+
+private:
+    VM::Value *stack;
+    unsigned stackSize;
+    const uchar **code;
+};
+
+#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; \
+    Q_UNUSED(instr); \
+    TRACE_INSTR(I)
+
+#ifdef MOTH_THREADED_INTERPRETER
+
+#  define MOTH_BEGIN_INSTR(I) op_##I: \
+    MOTH_BEGIN_INSTR_COMMON(I)
+
+#  define MOTH_NEXT_INSTR(I) { \
+    genericInstr = reinterpret_cast<const Instr *>(code); \
+    goto *genericInstr->common.code; \
+    }
+
+#  define MOTH_END_INSTR(I) } \
+    genericInstr = reinterpret_cast<const Instr *>(code); \
+    goto *genericInstr->common.code; \
+
+#else
+
+#  define MOTH_BEGIN_INSTR(I) \
+    case Instr::I: \
+    MOTH_BEGIN_INSTR_COMMON(I)
+
+#  define MOTH_NEXT_INSTR(I) { \
+    break; \
+    }
+
+#  define MOTH_END_INSTR(I) } \
+    break;
+
+#endif
+
+#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
+
+static inline VM::Value *getValueRef(QQmlJS::VM::ExecutionContext *context,
+                                     VM::Value* stack,
+                                     const Instr::Param &param
+#if !defined(QT_NO_DEBUG)
+                                     , unsigned stackSize
+#endif
+                                     )
+{
+#ifdef DO_TRACE_INSTR
+    if (param.isValue()) {
+        fprintf(stderr, "    value %s\n", param.value.toString(context)->toQString().toUtf8().constData());
+    } else if (param.isArgument()) {
+        fprintf(stderr, "    argument %d@%d\n", param.index, param.scope);
+    } else if (param.isLocal()) {
+        fprintf(stderr, "    local %d\n", param.index);
+    } else if (param.isTemp()) {
+        fprintf(stderr, "    temp %d\n", param.index);
+    } else if (param.isScopedLocal()) {
+        fprintf(stderr, "    temp %d@%d\n", param.index, param.scope);
+    } else {
+        Q_ASSERT(!"INVALID");
+    }
+#endif // DO_TRACE_INSTR
+
+    if (param.isValue()) {
+        VMSTATS(paramIsValue);
+        return const_cast<VM::Value *>(&param.value);
+    } else if (param.isArgument()) {
+        VMSTATS(paramIsArg);
+        VM::ExecutionContext *c = context;
+        uint scope = param.scope;
+        while (scope--)
+            c = c->outer;
+        VM::CallContext *cc = static_cast<VM::CallContext *>(c);
+        const unsigned arg = param.index;
+        Q_ASSERT(arg >= 0);
+        Q_ASSERT((unsigned) arg < cc->argumentCount);
+        Q_ASSERT(cc->arguments);
+        return cc->arguments + arg;
+    } else if (param.isLocal()) {
+        VMSTATS(paramIsLocal);
+        const unsigned index = param.index;
+        VM::CallContext *c = static_cast<VM::CallContext *>(context);
+        Q_ASSERT(index >= 0);
+        Q_ASSERT(index < context->variableCount());
+        Q_ASSERT(c->locals);
+        return c->locals + index;
+    } else if (param.isTemp()) {
+        VMSTATS(paramIsTemp);
+        Q_ASSERT(param.index < stackSize);
+        return stack + param.index;
+    } else if (param.isScopedLocal()) {
+        VMSTATS(paramIsScopedLocal);
+        VM::ExecutionContext *c = context;
+        uint scope = param.scope;
+        while (scope--)
+            c = c->outer;
+        const unsigned index = param.index;
+        VM::CallContext *cc = static_cast<VM::CallContext *>(c);
+        Q_ASSERT(index >= 0);
+        Q_ASSERT(index < cc->variableCount());
+        Q_ASSERT(cc->locals);
+        return cc->locals + index;
+    } else {
+        Q_UNIMPLEMENTED();
+        return 0;
+    }
+}
+
+#if defined(QT_NO_DEBUG)
+# define VALUE(param) *(VALUEPTR(param))
+
+// The non-temp case might need some tweaking for QML: there it would probably be a value instead of a local.
+# define VALUEPTR(param) \
+    param.isTemp() ? stack + param.index \
+                   : (param.isLocal() ? static_cast<VM::CallContext *>(context)->locals + param.index \
+                                      : getValueRef(context, stack, param))
+#else
+# define VALUE(param) *getValueRef(context, stack, param, stackSize)
+# define VALUEPTR(param) getValueRef(context, stack, param, stackSize)
+#endif
+
+VM::Value VME::run(QQmlJS::VM::ExecutionContext *context, const uchar *&code,
+        VM::Value *stack, unsigned stackSize
+#ifdef MOTH_THREADED_INTERPRETER
+        , void ***storeJumpTable
+#endif
+        )
+{
+#ifdef DO_TRACE_INSTR
+    qDebug("Starting VME with context=%p and code=%p", context, code);
+#endif // DO_TRACE_INSTR
+
+#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;
+        return VM::Value::undefinedValue();
+    }
+#endif
+
+    FunctionState state(context, &code);
+
+#ifdef MOTH_THREADED_INTERPRETER
+    const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
+    goto *genericInstr->common.code;
+#else
+    for (;;) {
+        const Instr *genericInstr = reinterpret_cast<const Instr *>(code);
+        switch (genericInstr->common.instructionType) {
+#endif
+
+    MOTH_BEGIN_INSTR(MoveTemp)
+        VALUE(instr.result) = VALUE(instr.source);
+    MOTH_END_INSTR(MoveTemp)
+
+    MOTH_BEGIN_INSTR(LoadValue)
+//        TRACE(value, "%s", instr.value.toString(context)->toQString().toUtf8().constData());
+        VALUE(instr.result) = VALUE(instr.value);
+    MOTH_END_INSTR(LoadValue)
+
+    MOTH_BEGIN_INSTR(LoadClosure)
+        __qmljs_init_closure(context, VALUEPTR(instr.result), instr.value);
+    MOTH_END_INSTR(LoadClosure)
+
+    MOTH_BEGIN_INSTR(LoadName)
+        TRACE(inline, "property name = %s", instr.name->toQString().toUtf8().constData());
+        __qmljs_get_activation_property(context, VALUEPTR(instr.result), instr.name);
+    MOTH_END_INSTR(LoadName)
+
+    MOTH_BEGIN_INSTR(StoreName)
+        TRACE(inline, "property name = %s", instr.name->toQString().toUtf8().constData());
+        __qmljs_set_activation_property(context, instr.name, VALUE(instr.source));
+    MOTH_END_INSTR(StoreName)
+
+    MOTH_BEGIN_INSTR(LoadElement)
+         __qmljs_get_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
+    MOTH_END_INSTR(LoadElement)
+
+    MOTH_BEGIN_INSTR(StoreElement)
+        __qmljs_set_element(context, VALUE(instr.base), VALUE(instr.index), VALUE(instr.source));
+    MOTH_END_INSTR(StoreElement)
+
+    MOTH_BEGIN_INSTR(LoadProperty)
+        __qmljs_get_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name);
+    MOTH_END_INSTR(LoadProperty)
+
+    MOTH_BEGIN_INSTR(StoreProperty)
+        __qmljs_set_property(context, VALUE(instr.base), instr.name, VALUE(instr.source));
+    MOTH_END_INSTR(StoreProperty)
+
+    MOTH_BEGIN_INSTR(Push)
+        TRACE(inline, "stack size: %u", instr.value);
+        stackSize = instr.value;
+        stack = static_cast<VM::Value *>(alloca(stackSize * sizeof(VM::Value)));
+        state.setStack(stack, stackSize);
+    MOTH_END_INSTR(Push)
+
+    MOTH_BEGIN_INSTR(CallValue)
+#ifdef DO_TRACE_INSTR
+        if (Debugging::Debugger *debugger = context->engine->debugger) {
+            if (VM::FunctionObject *o = (VALUE(instr.dest)).asFunctionObject()) {
+                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
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_call_value(context, VALUEPTR(instr.result), /*thisObject*/0, VALUE(instr.dest), args, instr.argc);
+    MOTH_END_INSTR(CallValue)
+
+    MOTH_BEGIN_INSTR(CallProperty)
+        TRACE(property name, "%s, args=%u, argc=%u, this=%s", qPrintable(instr.name->toQString()), instr.args, instr.argc, (VALUE(instr.base)).toString(context)->toQString().toUtf8().constData());
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_call_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name, args, instr.argc);
+    MOTH_END_INSTR(CallProperty)
+
+    MOTH_BEGIN_INSTR(CallElement)
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_call_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index), args, instr.argc);
+    MOTH_END_INSTR(CallElement)
+
+    MOTH_BEGIN_INSTR(CallActivationProperty)
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_call_activation_property(context, VALUEPTR(instr.result), instr.name, args, instr.argc);
+    MOTH_END_INSTR(CallActivationProperty)
+
+    MOTH_BEGIN_INSTR(CallBuiltinThrow)
+        __qmljs_builtin_throw(context, VALUE(instr.arg));
+    MOTH_END_INSTR(CallBuiltinThrow)
+
+    MOTH_BEGIN_INSTR(EnterTry)
+        VALUE(instr.exceptionVar) = VM::Value::undefinedValue();
+        try {
+            const uchar *tryCode = ((uchar *)&instr.tryOffset) + instr.tryOffset;
+            run(context, tryCode, stack, stackSize);
+            code = tryCode;
+        } catch (VM::Exception &ex) {
+            ex.accept(context);
+            VALUE(instr.exceptionVar) = ex.value();
+            try {
+                VM::ExecutionContext *catchContext = __qmljs_builtin_push_catch_scope(instr.exceptionVarName, ex.value(), context);
+                const uchar *catchCode = ((uchar *)&instr.catchOffset) + instr.catchOffset;
+                run(catchContext, catchCode, stack, stackSize);
+                code = catchCode;
+                context = __qmljs_builtin_pop_scope(catchContext);
+            } catch (VM::Exception &ex) {
+                ex.accept(context);
+                VALUE(instr.exceptionVar) = ex.value();
+                const uchar *catchCode = ((uchar *)&instr.catchOffset) + instr.catchOffset;
+                run(context, catchCode, stack, stackSize);
+                code = catchCode;
+            }
+        }
+    MOTH_END_INSTR(EnterTry)
+
+    MOTH_BEGIN_INSTR(CallBuiltinFinishTry)
+        return VM::Value();
+    MOTH_END_INSTR(CallBuiltinFinishTry)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPushScope)
+        context = __qmljs_builtin_push_with_scope(VALUE(instr.arg), context);
+    MOTH_END_INSTR(CallBuiltinPushScope)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPopScope)
+        context = __qmljs_builtin_pop_scope(context);
+    MOTH_END_INSTR(CallBuiltinPopScope)
+
+    MOTH_BEGIN_INSTR(CallBuiltinForeachIteratorObject)
+        __qmljs_foreach_iterator_object(context, VALUEPTR(instr.result), VALUE(instr.arg));
+    MOTH_END_INSTR(CallBuiltinForeachIteratorObject)
+
+    MOTH_BEGIN_INSTR(CallBuiltinForeachNextPropertyName)
+        __qmljs_foreach_next_property_name(VALUEPTR(instr.result), VALUE(instr.arg));
+    MOTH_END_INSTR(CallBuiltinForeachNextPropertyName)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDeleteMember)
+        __qmljs_delete_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
+    MOTH_END_INSTR(CallBuiltinDeleteMember)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDeleteSubscript)
+        __qmljs_delete_subscript(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
+    MOTH_END_INSTR(CallBuiltinDeleteSubscript)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDeleteName)
+        __qmljs_delete_name(context, VALUEPTR(instr.result), instr.name);
+    MOTH_END_INSTR(CallBuiltinDeleteName)
+
+    MOTH_BEGIN_INSTR(CallBuiltinTypeofMember)
+        __qmljs_builtin_typeof_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
+    MOTH_END_INSTR(CallBuiltinTypeofMember)
+
+    MOTH_BEGIN_INSTR(CallBuiltinTypeofSubscript)
+        __qmljs_builtin_typeof_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
+    MOTH_END_INSTR(CallBuiltinTypeofSubscript)
+
+    MOTH_BEGIN_INSTR(CallBuiltinTypeofName)
+        __qmljs_builtin_typeof_name(context, VALUEPTR(instr.result), instr.name);
+    MOTH_END_INSTR(CallBuiltinTypeofName)
+
+    MOTH_BEGIN_INSTR(CallBuiltinTypeofValue)
+        __qmljs_builtin_typeof(context, VALUEPTR(instr.result), VALUE(instr.value));
+    MOTH_END_INSTR(CallBuiltinTypeofValue)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostIncMember)
+        __qmljs_builtin_post_increment_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
+    MOTH_END_INSTR(CallBuiltinTypeofMember)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostIncSubscript)
+        __qmljs_builtin_post_increment_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUEPTR(instr.index));
+    MOTH_END_INSTR(CallBuiltinTypeofSubscript)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostIncName)
+        __qmljs_builtin_post_increment_name(context, VALUEPTR(instr.result), instr.name);
+    MOTH_END_INSTR(CallBuiltinTypeofName)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostIncValue)
+        __qmljs_builtin_post_increment(VALUEPTR(instr.result), VALUEPTR(instr.value));
+    MOTH_END_INSTR(CallBuiltinTypeofValue)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostDecMember)
+        __qmljs_builtin_post_decrement_member(context, VALUEPTR(instr.result), VALUE(instr.base), instr.member);
+    MOTH_END_INSTR(CallBuiltinTypeofMember)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostDecSubscript)
+        __qmljs_builtin_post_decrement_element(context, VALUEPTR(instr.result), VALUE(instr.base), VALUE(instr.index));
+    MOTH_END_INSTR(CallBuiltinTypeofSubscript)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostDecName)
+        __qmljs_builtin_post_decrement_name(context, VALUEPTR(instr.result), instr.name);
+    MOTH_END_INSTR(CallBuiltinTypeofName)
+
+    MOTH_BEGIN_INSTR(CallBuiltinPostDecValue)
+        __qmljs_builtin_post_decrement(VALUEPTR(instr.result), VALUEPTR(instr.value));
+    MOTH_END_INSTR(CallBuiltinTypeofValue)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDeclareVar)
+        __qmljs_builtin_declare_var(context, instr.isDeletable, instr.varName);
+    MOTH_END_INSTR(CallBuiltinDeclareVar)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDefineGetterSetter)
+        __qmljs_builtin_define_getter_setter(context, VALUE(instr.object), instr.name, VALUEPTR(instr.getter), VALUEPTR(instr.setter));
+    MOTH_END_INSTR(CallBuiltinDefineGetterSetter)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDefineProperty)
+        __qmljs_builtin_define_property(context, VALUE(instr.object), instr.name, VALUEPTR(instr.value));
+    MOTH_END_INSTR(CallBuiltinDefineProperty)
+
+    MOTH_BEGIN_INSTR(CallBuiltinDefineArray)
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_builtin_define_array(context, VALUEPTR(instr.result), args, instr.argc);
+    MOTH_END_INSTR(CallBuiltinDefineArray)
+
+    MOTH_BEGIN_INSTR(CreateValue)
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_construct_value(context, VALUEPTR(instr.result), VALUE(instr.func), args, instr.argc);
+    MOTH_END_INSTR(CreateValue)
+
+    MOTH_BEGIN_INSTR(CreateProperty)
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_construct_property(context, VALUEPTR(instr.result), VALUE(instr.base), instr.name, args, instr.argc);
+    MOTH_END_INSTR(CreateProperty)
+
+    MOTH_BEGIN_INSTR(CreateActivationProperty)
+        TRACE(inline, "property name = %s, args = %d, argc = %d", instr.name->toQString().toUtf8().constData(), instr.args, instr.argc);
+        Q_ASSERT(instr.args + instr.argc <= stackSize);
+        VM::Value *args = stack + instr.args;
+        __qmljs_construct_activation_property(context, VALUEPTR(instr.result), instr.name, args, instr.argc);
+    MOTH_END_INSTR(CreateActivationProperty)
+
+    MOTH_BEGIN_INSTR(Jump)
+        code = ((uchar *)&instr.offset) + instr.offset;
+    MOTH_END_INSTR(Jump)
+
+    MOTH_BEGIN_INSTR(CJump)
+        uint cond = __qmljs_to_boolean(VALUE(instr.condition));
+        TRACE(condition, "%s", cond ? "TRUE" : "FALSE");
+        if (cond)
+            code = ((uchar *)&instr.offset) + instr.offset;
+    MOTH_END_INSTR(CJump)
+
+    MOTH_BEGIN_INSTR(Unop)
+        instr.alu(VALUEPTR(instr.result), VALUE(instr.source));
+    MOTH_END_INSTR(Unop)
+
+    MOTH_BEGIN_INSTR(Binop)
+        instr.alu(context, VALUEPTR(instr.result), VALUE(instr.lhs), VALUE(instr.rhs));
+    MOTH_END_INSTR(Binop)
+
+    MOTH_BEGIN_INSTR(Ret)
+        VM::Value &result = VALUE(instr.result);
+//        TRACE(Ret, "returning value %s", result.toString(context)->toQString().toUtf8().constData());
+        return result;
+    MOTH_END_INSTR(Ret)
+
+    MOTH_BEGIN_INSTR(LoadThis)
+        VALUE(instr.result) = context->thisObject;
+    MOTH_END_INSTR(LoadThis)
+
+    MOTH_BEGIN_INSTR(InplaceElementOp)
+        instr.alu(context,
+                  VALUE(instr.base),
+                  VALUE(instr.index),
+                  VALUE(instr.source));
+    MOTH_END_INSTR(InplaceElementOp)
+
+    MOTH_BEGIN_INSTR(InplaceMemberOp)
+        instr.alu(context,
+                  VALUE(instr.base),
+                  instr.member,
+                  VALUE(instr.source));
+    MOTH_END_INSTR(InplaceMemberOp)
+
+    MOTH_BEGIN_INSTR(InplaceNameOp)
+        TRACE(name, "%s", instr.name->toQString().toUtf8().constData());
+        instr.alu(context, instr.name, VALUE(instr.source));
+    MOTH_END_INSTR(InplaceNameOp)
+
+#ifdef MOTH_THREADED_INTERPRETER
+    // nothing to do
+#else
+        default:
+            qFatal("QQmlJS::Moth::VME: Internal error - unknown instruction %d", genericInstr->common.instructionType);
+            break;
+        }
+    }
+#endif
+
+}
+
+#ifdef MOTH_THREADED_INTERPRETER
+void **VME::instructionJumpTable()
+{
+    static void **jumpTable = 0;
+    if (!jumpTable) {
+        const uchar *code = 0;
+        VME().run(0, code, 0, 0, &jumpTable);
+    }
+    return jumpTable;
+}
+#endif
+
+VM::Value VME::exec(VM::ExecutionContext *ctxt, const uchar *code)
+{
+    VME vme;
+    return vme.run(ctxt, code);
+}
diff --git a/src/qml/qml/v4vm/moth/qv4vme_moth_p.h b/src/qml/qml/v4vm/moth/qv4vme_moth_p.h
new file mode 100644
index 0000000000..9eea23901a
--- /dev/null
+++ b/src/qml/qml/v4vm/moth/qv4vme_moth_p.h
@@ -0,0 +1,35 @@
+#ifndef QV4VME_MOTH_P_H
+#define QV4VME_MOTH_P_H
+
+#include "qv4runtime.h"
+#include "qv4instr_moth_p.h"
+
+namespace QQmlJS {
+namespace VM {
+    struct Value;
+}
+
+namespace Moth {
+
+class VME
+{
+public:
+    static VM::Value exec(VM::ExecutionContext *, const uchar *);
+
+#ifdef MOTH_THREADED_INTERPRETER
+    static void **instructionJumpTable();
+#endif
+
+private:
+    VM::Value run(QQmlJS::VM::ExecutionContext *, const uchar *&code,
+            VM::Value *stack = 0, unsigned stackSize = 0
+#ifdef MOTH_THREADED_INTERPRETER
+            , void ***storeJumpTable = 0
+#endif
+            );
+};
+
+} // namespace Moth
+} // namespace QQmlJS
+
+#endif // QV4VME_MOTH_P_H