V4: remove inplace operations

Inplace operations are expanded when building the IR, so the neither the
IR, nor the instruction selection backends or runtime need to handle
them.

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

12 files changed, 86 insertions, 334 deletions

diff --git a/src/qml/compiler/qv4codegen.cpp b/src/qml/compiler/qv4codegen.cpp
index 74aa0892f9..0f60bdc9f3 100644
--- a/src/qml/compiler/qv4codegen.cpp
+++ b/src/qml/compiler/qv4codegen.cpp
@@ -655,24 +655,23 @@ void Codegen::move(V4IR::Expr *target, V4IR::Expr *source, V4IR::AluOp op)
 {
     assert(target->isLValue());
 
-    // TODO: verify the rest of the function for when op == OpInvalid
     if (op != V4IR::OpInvalid) {
-        move(target, binop(op, target, source), V4IR::OpInvalid);
+        move(target, binop(op, target, source));
         return;
     }
 
-    if (!source->asTemp() && !source->asConst() && (op != V4IR::OpInvalid || ! target->asTemp())) {
+    if (!source->asTemp() && !source->asConst() && !target->asTemp()) {
         unsigned t = _block->newTemp();
         _block->MOVE(_block->TEMP(t), source);
         source = _block->TEMP(t);
     }
-    if (source->asConst() && (!target->asTemp() || op != V4IR::OpInvalid)) {
+    if (source->asConst() && !target->asTemp()) {
         unsigned t = _block->newTemp();
         _block->MOVE(_block->TEMP(t), source);
         source = _block->TEMP(t);
     }
 
-    _block->MOVE(target, source, op);
+    _block->MOVE(target, source);
 }
 
 void Codegen::cjump(V4IR::Expr *cond, V4IR::BasicBlock *iftrue, V4IR::BasicBlock *iffalse)
diff --git a/src/qml/compiler/qv4instr_moth_p.h b/src/qml/compiler/qv4instr_moth_p.h
index af1ca0ae76..100b6f65a6 100644
--- a/src/qml/compiler/qv4instr_moth_p.h
+++ b/src/qml/compiler/qv4instr_moth_p.h
@@ -99,10 +99,7 @@ QT_BEGIN_NAMESPACE
     F(AddNumberParams, addNumberParams) \
     F(MulNumberParams, mulNumberParams) \
     F(SubNumberParams, subNumberParams) \
-    F(LoadThis, loadThis) \
-    F(InplaceElementOp, inplaceElementOp) \
-    F(InplaceMemberOp, inplaceMemberOp) \
-    F(InplaceNameOp, inplaceNameOp)
+    F(LoadThis, loadThis)
 
 #if defined(Q_CC_GNU) && (!defined(Q_CC_INTEL) || __INTEL_COMPILER >= 1200)
 #  define MOTH_THREADED_INTERPRETER
@@ -484,26 +481,6 @@ union Instr
         MOTH_INSTR_HEADER
         Param result;
     };
-    struct instr_inplaceElementOp {
-        MOTH_INSTR_HEADER
-        QV4::InplaceBinOpElement alu;
-        Param base;
-        Param index;
-        Param source;
-    };
-    struct instr_inplaceMemberOp {
-        MOTH_INSTR_HEADER
-        QV4::InplaceBinOpMember alu;
-        int member;
-        Param base;
-        Param source;
-    };
-    struct instr_inplaceNameOp {
-        MOTH_INSTR_HEADER
-        QV4::InplaceBinOpName alu;
-        int name;
-        Param source;
-    };
 
     instr_common common;
     instr_ret ret;
@@ -556,9 +533,6 @@ union Instr
     instr_mulNumberParams mulNumberParams;
     instr_subNumberParams subNumberParams;
     instr_loadThis loadThis;
-    instr_inplaceElementOp inplaceElementOp;
-    instr_inplaceMemberOp inplaceMemberOp;
-    instr_inplaceNameOp inplaceNameOp;
 
     static int size(Type type);
 };
diff --git a/src/qml/compiler/qv4isel_masm.cpp b/src/qml/compiler/qv4isel_masm.cpp
index 0a5b94f66c..b7ce1cc86e 100644
--- a/src/qml/compiler/qv4isel_masm.cpp
+++ b/src/qml/compiler/qv4isel_masm.cpp
@@ -1369,88 +1369,6 @@ void InstructionSelection::binop(V4IR::AluOp oper, V4IR::Expr *leftSource, V4IR:
         done.link(_as);
 }
 
-void InstructionSelection::inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName)
-{
-    InplaceBinOpName op = 0;
-    const char *opName = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: setOp(op, opName, __qmljs_inplace_bit_and_name); break;
-    case V4IR::OpBitOr: setOp(op, opName, __qmljs_inplace_bit_or_name); break;
-    case V4IR::OpBitXor: setOp(op, opName, __qmljs_inplace_bit_xor_name); break;
-    case V4IR::OpAdd: setOp(op, opName, __qmljs_inplace_add_name); break;
-    case V4IR::OpSub: setOp(op, opName, __qmljs_inplace_sub_name); break;
-    case V4IR::OpMul: setOp(op, opName, __qmljs_inplace_mul_name); break;
-    case V4IR::OpDiv: setOp(op, opName, __qmljs_inplace_div_name); break;
-    case V4IR::OpMod: setOp(op, opName, __qmljs_inplace_mod_name); break;
-    case V4IR::OpLShift: setOp(op, opName, __qmljs_inplace_shl_name); break;
-    case V4IR::OpRShift: setOp(op, opName, __qmljs_inplace_shr_name); break;
-    case V4IR::OpURShift: setOp(op, opName, __qmljs_inplace_ushr_name); break;
-    default:
-        Q_UNREACHABLE();
-        break;
-    }
-    if (op) {
-        _as->generateFunctionCallImp(Assembler::Void, opName, op, Assembler::ContextRegister,
-                                     Assembler::PointerToString(targetName), Assembler::Reference(rightSource));
-    }
-}
-
-void InstructionSelection::inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp)
-{
-    InplaceBinOpElement op = 0;
-    const char *opName = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: setOp(op, opName, __qmljs_inplace_bit_and_element); break;
-    case V4IR::OpBitOr: setOp(op, opName, __qmljs_inplace_bit_or_element); break;
-    case V4IR::OpBitXor: setOp(op, opName, __qmljs_inplace_bit_xor_element); break;
-    case V4IR::OpAdd: setOp(op, opName, __qmljs_inplace_add_element); break;
-    case V4IR::OpSub: setOp(op, opName, __qmljs_inplace_sub_element); break;
-    case V4IR::OpMul: setOp(op, opName, __qmljs_inplace_mul_element); break;
-    case V4IR::OpDiv: setOp(op, opName, __qmljs_inplace_div_element); break;
-    case V4IR::OpMod: setOp(op, opName, __qmljs_inplace_mod_element); break;
-    case V4IR::OpLShift: setOp(op, opName, __qmljs_inplace_shl_element); break;
-    case V4IR::OpRShift: setOp(op, opName, __qmljs_inplace_shr_element); break;
-    case V4IR::OpURShift: setOp(op, opName, __qmljs_inplace_ushr_element); break;
-    default:
-        Q_UNREACHABLE();
-        break;
-    }
-
-    if (op) {
-        _as->generateFunctionCallImp(Assembler::Void, opName, op, Assembler::ContextRegister,
-                                     Assembler::Reference(targetBaseTemp), Assembler::Reference(targetIndexTemp),
-                                     Assembler::Reference(source));
-    }
-}
-
-void InstructionSelection::inplaceMemberOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName)
-{
-    InplaceBinOpMember op = 0;
-    const char *opName = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: setOp(op, opName, __qmljs_inplace_bit_and_member); break;
-    case V4IR::OpBitOr: setOp(op, opName, __qmljs_inplace_bit_or_member); break;
-    case V4IR::OpBitXor: setOp(op, opName, __qmljs_inplace_bit_xor_member); break;
-    case V4IR::OpAdd: setOp(op, opName, __qmljs_inplace_add_member); break;
-    case V4IR::OpSub: setOp(op, opName, __qmljs_inplace_sub_member); break;
-    case V4IR::OpMul: setOp(op, opName, __qmljs_inplace_mul_member); break;
-    case V4IR::OpDiv: setOp(op, opName, __qmljs_inplace_div_member); break;
-    case V4IR::OpMod: setOp(op, opName, __qmljs_inplace_mod_member); break;
-    case V4IR::OpLShift: setOp(op, opName, __qmljs_inplace_shl_member); break;
-    case V4IR::OpRShift: setOp(op, opName, __qmljs_inplace_shr_member); break;
-    case V4IR::OpURShift: setOp(op, opName, __qmljs_inplace_ushr_member); break;
-    default:
-        Q_UNREACHABLE();
-        break;
-    }
-
-    if (op) {
-        _as->generateFunctionCallImp(Assembler::Void, opName, op, Assembler::ContextRegister,
-                                     Assembler::Reference(targetBase), Assembler::PointerToString(targetName),
-                                     Assembler::Reference(source));
-    }
-}
-
 void InstructionSelection::callProperty(V4IR::Expr *base, const QString &name, V4IR::ExprList *args,
                                         V4IR::Temp *result)
 {
diff --git a/src/qml/compiler/qv4isel_masm_p.h b/src/qml/compiler/qv4isel_masm_p.h
index a9355bd6e5..c233af0b99 100644
--- a/src/qml/compiler/qv4isel_masm_p.h
+++ b/src/qml/compiler/qv4isel_masm_p.h
@@ -1403,9 +1403,6 @@ protected:
     virtual void swapValues(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::Expr *leftSource, V4IR::Expr *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);
 
     typedef Assembler::Address Address;
     typedef Assembler::Pointer Pointer;
diff --git a/src/qml/compiler/qv4isel_moth.cpp b/src/qml/compiler/qv4isel_moth.cpp
index 35fca99df4..af914c79e7 100644
--- a/src/qml/compiler/qv4isel_moth.cpp
+++ b/src/qml/compiler/qv4isel_moth.cpp
@@ -604,85 +604,6 @@ Param InstructionSelection::binopHelper(V4IR::AluOp oper, V4IR::Expr *leftSource
     }
 }
 
-void InstructionSelection::inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName)
-{
-    QV4::InplaceBinOpName op = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: op = QV4::__qmljs_inplace_bit_and_name; break;
-    case V4IR::OpBitOr: op = QV4::__qmljs_inplace_bit_or_name; break;
-    case V4IR::OpBitXor: op = QV4::__qmljs_inplace_bit_xor_name; break;
-    case V4IR::OpAdd: op = QV4::__qmljs_inplace_add_name; break;
-    case V4IR::OpSub: op = QV4::__qmljs_inplace_sub_name; break;
-    case V4IR::OpMul: op = QV4::__qmljs_inplace_mul_name; break;
-    case V4IR::OpDiv: op = QV4::__qmljs_inplace_div_name; break;
-    case V4IR::OpMod: op = QV4::__qmljs_inplace_mod_name; break;
-    case V4IR::OpLShift: op = QV4::__qmljs_inplace_shl_name; break;
-    case V4IR::OpRShift: op = QV4::__qmljs_inplace_shr_name; break;
-    case V4IR::OpURShift: op = QV4::__qmljs_inplace_ushr_name; break;
-    default: break;
-    }
-
-    if (op) {
-        Instruction::InplaceNameOp ieo;
-        ieo.alu = op;
-        ieo.name = registerString(targetName);
-        ieo.source = getParam(rightSource);
-        addInstruction(ieo);
-    }
-}
-
-void InstructionSelection::inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp)
-{
-    QV4::InplaceBinOpElement op = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: op = QV4::__qmljs_inplace_bit_and_element; break;
-    case V4IR::OpBitOr: op = QV4::__qmljs_inplace_bit_or_element; break;
-    case V4IR::OpBitXor: op = QV4::__qmljs_inplace_bit_xor_element; break;
-    case V4IR::OpAdd: op = QV4::__qmljs_inplace_add_element; break;
-    case V4IR::OpSub: op = QV4::__qmljs_inplace_sub_element; break;
-    case V4IR::OpMul: op = QV4::__qmljs_inplace_mul_element; break;
-    case V4IR::OpDiv: op = QV4::__qmljs_inplace_div_element; break;
-    case V4IR::OpMod: op = QV4::__qmljs_inplace_mod_element; break;
-    case V4IR::OpLShift: op = QV4::__qmljs_inplace_shl_element; break;
-    case V4IR::OpRShift: op = QV4::__qmljs_inplace_shr_element; break;
-    case V4IR::OpURShift: op = QV4::__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)
-{
-    QV4::InplaceBinOpMember op = 0;
-    switch (oper) {
-    case V4IR::OpBitAnd: op = QV4::__qmljs_inplace_bit_and_member; break;
-    case V4IR::OpBitOr: op = QV4::__qmljs_inplace_bit_or_member; break;
-    case V4IR::OpBitXor: op = QV4::__qmljs_inplace_bit_xor_member; break;
-    case V4IR::OpAdd: op = QV4::__qmljs_inplace_add_member; break;
-    case V4IR::OpSub: op = QV4::__qmljs_inplace_sub_member; break;
-    case V4IR::OpMul: op = QV4::__qmljs_inplace_mul_member; break;
-    case V4IR::OpDiv: op = QV4::__qmljs_inplace_div_member; break;
-    case V4IR::OpMod: op = QV4::__qmljs_inplace_mod_member; break;
-    case V4IR::OpLShift: op = QV4::__qmljs_inplace_shl_member; break;
-    case V4IR::OpRShift: op = QV4::__qmljs_inplace_shr_member; break;
-    case V4IR::OpURShift: op = QV4::__qmljs_inplace_ushr_member; break;
-    default: break;
-    }
-
-    Instruction::InplaceMemberOp imo;
-    imo.alu = op;
-    imo.base = getParam(targetBase);
-    imo.member = registerString(targetName);
-    imo.source = getParam(source);
-    addInstruction(imo);
-}
-
 void InstructionSelection::prepareCallArgs(V4IR::ExprList *e, quint32 &argc, quint32 *args)
 {
     int argLocation = outgoingArgumentTempStart();
diff --git a/src/qml/compiler/qv4isel_moth_p.h b/src/qml/compiler/qv4isel_moth_p.h
index ee0b7276cb..8482e358e2 100644
--- a/src/qml/compiler/qv4isel_moth_p.h
+++ b/src/qml/compiler/qv4isel_moth_p.h
@@ -127,9 +127,6 @@ protected:
     virtual void swapValues(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::Expr *leftSource, V4IR::Expr *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:
     Param binopHelper(V4IR::AluOp oper, V4IR::Expr *leftSource, V4IR::Expr *rightSource, V4IR::Temp *target);
diff --git a/src/qml/compiler/qv4isel_p.cpp b/src/qml/compiler/qv4isel_p.cpp
index 2f66628fea..500c2bd26f 100644
--- a/src/qml/compiler/qv4isel_p.cpp
+++ b/src/qml/compiler/qv4isel_p.cpp
@@ -96,120 +96,94 @@ QV4::CompiledData::CompilationUnit *EvalInstructionSelection::compile(bool gener
 
 void IRDecoder::visitMove(V4IR::Move *s)
 {
-    if (s->op == V4IR::OpInvalid) {
-        if (V4IR::Name *n = s->target->asName()) {
-            if (s->source->asTemp() || s->source->asConst()) {
-                setActivationProperty(s->source, *n->id);
-                return;
-            }
-        } else if (V4IR::Temp *t = s->target->asTemp()) {
-            if (V4IR::Name *n = s->source->asName()) {
-                if (*n->id == QStringLiteral("this")) // TODO: `this' should be a builtin.
-                    loadThisObject(t);
-                else
-                    getActivationProperty(n, t);
-                return;
-            } else if (V4IR::Const *c = s->source->asConst()) {
-                loadConst(c, t);
-                return;
-            } else if (V4IR::Temp *t2 = s->source->asTemp()) {
-                if (s->swap)
-                    swapValues(t2, t);
-                else
-                    copyValue(t2, t);
-                return;
-            } else if (V4IR::String *str = s->source->asString()) {
-                loadString(*str->value, t);
-                return;
-            } else if (V4IR::RegExp *re = s->source->asRegExp()) {
-                loadRegexp(re, t);
-                return;
-            } else if (V4IR::Closure *clos = s->source->asClosure()) {
-                initClosure(clos, t);
-                return;
-            } else if (V4IR::New *ctor = s->source->asNew()) {
-                if (Name *func = ctor->base->asName()) {
-                    constructActivationProperty(func, ctor->args, t);
-                    return;
-                } else if (V4IR::Member *member = ctor->base->asMember()) {
-                    constructProperty(member->base->asTemp(), *member->name, ctor->args, t);
-                    return;
-                } else if (V4IR::Temp *value = ctor->base->asTemp()) {
-                    constructValue(value, ctor->args, t);
-                    return;
-                }
-            } else if (V4IR::Member *m = s->source->asMember()) {
-                if (m->base->asTemp() || m->base->asConst()) {
-                    getProperty(m->base, *m->name, t);
-                    return;
-                }
-            } else if (V4IR::Subscript *ss = s->source->asSubscript()) {
-                getElement(ss->base->asTemp(), ss->index, t);
+    if (V4IR::Name *n = s->target->asName()) {
+        if (s->source->asTemp() || s->source->asConst()) {
+            setActivationProperty(s->source, *n->id);
+            return;
+        }
+    } else if (V4IR::Temp *t = s->target->asTemp()) {
+        if (V4IR::Name *n = s->source->asName()) {
+            if (*n->id == QStringLiteral("this")) // TODO: `this' should be a builtin.
+                loadThisObject(t);
+            else
+                getActivationProperty(n, t);
+            return;
+        } else if (V4IR::Const *c = s->source->asConst()) {
+            loadConst(c, t);
+            return;
+        } else if (V4IR::Temp *t2 = s->source->asTemp()) {
+            if (s->swap)
+                swapValues(t2, t);
+            else
+                copyValue(t2, t);
+            return;
+        } else if (V4IR::String *str = s->source->asString()) {
+            loadString(*str->value, t);
+            return;
+        } else if (V4IR::RegExp *re = s->source->asRegExp()) {
+            loadRegexp(re, t);
+            return;
+        } else if (V4IR::Closure *clos = s->source->asClosure()) {
+            initClosure(clos, t);
+            return;
+        } else if (V4IR::New *ctor = s->source->asNew()) {
+            if (Name *func = ctor->base->asName()) {
+                constructActivationProperty(func, ctor->args, t);
                 return;
-            } else if (V4IR::Unop *u = s->source->asUnop()) {
-                if (V4IR::Temp *e = u->expr->asTemp()) {
-                    unop(u->op, e, t);
-                    return;
-                }
-            } else if (V4IR::Binop *b = s->source->asBinop()) {
-                binop(b->op, b->left, b->right, t);
+            } else if (V4IR::Member *member = ctor->base->asMember()) {
+                constructProperty(member->base->asTemp(), *member->name, ctor->args, t);
                 return;
-            } else if (V4IR::Call *c = s->source->asCall()) {
-                if (c->base->asName()) {
-                    callBuiltin(c, t);
-                    return;
-                } else if (Member *member = c->base->asMember()) {
-                    callProperty(member->base, *member->name, c->args, t);
-                    return;
-                } else if (Subscript *ss = c->base->asSubscript()) {
-                    callSubscript(ss->base, ss->index, c->args, t);
-                    return;
-                } else if (V4IR::Temp *value = c->base->asTemp()) {
-                    callValue(value, c->args, t);
-                    return;
-                }
-            } else if (V4IR::Convert *c = s->source->asConvert()) {
-                Q_ASSERT(c->expr->asTemp());
-                convertType(c->expr->asTemp(), t);
+            } else if (V4IR::Temp *value = ctor->base->asTemp()) {
+                constructValue(value, ctor->args, t);
                 return;
             }
-        } else if (V4IR::Member *m = s->target->asMember()) {
+        } else if (V4IR::Member *m = s->source->asMember()) {
             if (m->base->asTemp() || m->base->asConst()) {
-                if (s->source->asTemp() || s->source->asConst()) {
-                    setProperty(s->source, m->base, *m->name);
-                    return;
-                }
-            }
-        } else if (V4IR::Subscript *ss = s->target->asSubscript()) {
-            if (s->source->asTemp() || s->source->asConst()) {
-                setElement(s->source, ss->base, ss->index);
+                getProperty(m->base, *m->name, t);
                 return;
             }
-        }
-    } else {
-        // inplace assignment, e.g. x += 1, ++x, ...
-        if (V4IR::Temp *t = s->target->asTemp()) {
-            if (s->source->asTemp()) {
-                binop(s->op, t, s->source->asTemp(), t);
+        } else if (V4IR::Subscript *ss = s->source->asSubscript()) {
+            getElement(ss->base->asTemp(), ss->index, t);
+            return;
+        } else if (V4IR::Unop *u = s->source->asUnop()) {
+            if (V4IR::Temp *e = u->expr->asTemp()) {
+                unop(u->op, e, t);
                 return;
             }
-        } else if (V4IR::Name *n = s->target->asName()) {
-            if (s->source->asTemp()) {
-                inplaceNameOp(s->op, s->source->asTemp(), *n->id);
+        } else if (V4IR::Binop *b = s->source->asBinop()) {
+            binop(b->op, b->left, b->right, t);
+            return;
+        } else if (V4IR::Call *c = s->source->asCall()) {
+            if (c->base->asName()) {
+                callBuiltin(c, t);
                 return;
-            }
-        } else if (V4IR::Subscript *ss = s->target->asSubscript()) {
-            if (s->source->asTemp()) {
-                inplaceElementOp(s->op, s->source->asTemp(), ss->base->asTemp(),
-                                 ss->index->asTemp());
+            } else if (Member *member = c->base->asMember()) {
+                callProperty(member->base, *member->name, c->args, t);
+                return;
+            } else if (Subscript *ss = c->base->asSubscript()) {
+                callSubscript(ss->base, ss->index, c->args, t);
+                return;
+            } else if (V4IR::Temp *value = c->base->asTemp()) {
+                callValue(value, c->args, t);
                 return;
             }
-        } else if (V4IR::Member *m = s->target->asMember()) {
-            if (s->source->asTemp()) {
-                inplaceMemberOp(s->op, s->source->asTemp(), m->base->asTemp(), *m->name);
+        } else if (V4IR::Convert *c = s->source->asConvert()) {
+            Q_ASSERT(c->expr->asTemp());
+            convertType(c->expr->asTemp(), t);
+            return;
+        }
+    } else if (V4IR::Member *m = s->target->asMember()) {
+        if (m->base->asTemp() || m->base->asConst()) {
+            if (s->source->asTemp() || s->source->asConst()) {
+                setProperty(s->source, m->base, *m->name);
                 return;
             }
         }
+    } else if (V4IR::Subscript *ss = s->target->asSubscript()) {
+        if (s->source->asTemp() || s->source->asConst()) {
+            setElement(s->source, ss->base, ss->index);
+            return;
+        }
     }
 
     // For anything else...:
diff --git a/src/qml/compiler/qv4isel_p.h b/src/qml/compiler/qv4isel_p.h
index 4b82d154d9..8fd59b609c 100644
--- a/src/qml/compiler/qv4isel_p.h
+++ b/src/qml/compiler/qv4isel_p.h
@@ -152,9 +152,6 @@ public: // to implement by subclasses:
     virtual void swapValues(V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp) = 0;
     virtual void unop(V4IR::AluOp oper, V4IR::Temp *sourceTemp, V4IR::Temp *targetTemp) = 0;
     virtual void binop(V4IR::AluOp oper, V4IR::Expr *leftSource, V4IR::Expr *rightSource, V4IR::Temp *target) = 0;
-    virtual void inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName) = 0;
-    virtual void inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp) = 0;
-    virtual void inplaceMemberOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName) = 0;
 
 protected:
     virtual void callBuiltin(V4IR::Call *c, V4IR::Temp *result);
diff --git a/src/qml/compiler/qv4jsir.cpp b/src/qml/compiler/qv4jsir.cpp
index 69771837fe..756c076abf 100644
--- a/src/qml/compiler/qv4jsir.cpp
+++ b/src/qml/compiler/qv4jsir.cpp
@@ -546,8 +546,6 @@ void Move::dump(QTextStream &out, Mode mode)
 
     target->dump(out);
     out << ' ';
-    if (op != OpInvalid)
-        out << opname(op);
     if (swap)
         out << "<=> ";
     else
@@ -836,13 +834,13 @@ Stmt *BasicBlock::EXP(Expr *expr)
     return s;
 }
 
-Stmt *BasicBlock::MOVE(Expr *target, Expr *source, AluOp op)
+Stmt *BasicBlock::MOVE(Expr *target, Expr *source)
 { 
     if (isTerminated())
         return 0;
 
     Move *s = function->New<Move>();
-    s->init(target, source, op);
+    s->init(target, source);
     appendStatement(s);
     return s;
 }
diff --git a/src/qml/compiler/qv4jsir_p.h b/src/qml/compiler/qv4jsir_p.h
index 67168ef951..f28c47a61a 100644
--- a/src/qml/compiler/qv4jsir_p.h
+++ b/src/qml/compiler/qv4jsir_p.h
@@ -577,14 +577,12 @@ struct Exp: Stmt {
 struct Move: Stmt {
     Expr *target; // LHS - Temp, Name, Member or Subscript
     Expr *source;
-    AluOp op;
     bool swap;
 
-    void init(Expr *target, Expr *source, AluOp op)
+    void init(Expr *target, Expr *source)
     {
         this->target = target;
         this->source = source;
-        this->op = op;
         this->swap = false;
     }
 
@@ -826,7 +824,7 @@ struct BasicBlock {
 
     Stmt *EXP(Expr *expr);
 
-    Stmt *MOVE(Expr *target, Expr *source, AluOp op = V4IR::OpInvalid);
+    Stmt *MOVE(Expr *target, Expr *source);
 
     Stmt *JUMP(BasicBlock *target);
     Stmt *CJUMP(Expr *cond, BasicBlock *iftrue, BasicBlock *iffalse);
diff --git a/src/qml/compiler/qv4regalloc.cpp b/src/qml/compiler/qv4regalloc.cpp
index 20036d3be4..7fd5864af3 100644
--- a/src/qml/compiler/qv4regalloc.cpp
+++ b/src/qml/compiler/qv4regalloc.cpp
@@ -480,24 +480,6 @@ protected: // IRDecoder
         }
     }
 
-    virtual void inplaceNameOp(V4IR::AluOp oper, V4IR::Temp *rightSource, const QString &targetName)
-    {
-        Q_UNREACHABLE();
-        // TODO: remove this!
-    }
-
-    virtual void inplaceElementOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBaseTemp, V4IR::Temp *targetIndexTemp)
-    {
-        Q_UNREACHABLE();
-        // TODO: remove this!
-    }
-
-    virtual void inplaceMemberOp(V4IR::AluOp oper, V4IR::Temp *source, V4IR::Temp *targetBase, const QString &targetName)
-    {
-        Q_UNREACHABLE();
-        // TODO: remove this!
-    }
-
     virtual void visitJump(V4IR::Jump *) {}
     virtual void visitCJump(V4IR::CJump *s)
     {
@@ -906,8 +888,7 @@ private:
 
         Move *store = _function->New<Move>();
         store->init(createTemp(Temp::StackSlot, spillSlot, type),
-                    createTemp(Temp::PhysicalRegister, pReg, type),
-                    V4IR::OpInvalid);
+                    createTemp(Temp::PhysicalRegister, pReg, type));
         return store;
     }
 
@@ -918,8 +899,7 @@ private:
         Q_ASSERT(spillSlot != -1);
         Move *load = _function->New<Move>();
         load->init(createTemp(Temp::PhysicalRegister, pReg, t.type),
-                   createTemp(Temp::StackSlot, spillSlot, t.type),
-                   V4IR::OpInvalid);
+                   createTemp(Temp::StackSlot, spillSlot, t.type));
         return load;
     }
 
diff --git a/src/qml/compiler/qv4ssa.cpp b/src/qml/compiler/qv4ssa.cpp
index 7054d5140c..c79f19ecf7 100644
--- a/src/qml/compiler/qv4ssa.cpp
+++ b/src/qml/compiler/qv4ssa.cpp
@@ -1462,7 +1462,6 @@ protected:
     virtual void visitExp(Exp *s) { _ty = run(s->expr); }
     virtual void visitMove(Move *s) {
         TypingResult sourceTy = run(s->source);
-        Q_ASSERT(s->op == OpInvalid);
         if (Temp *t = s->target->asTemp()) {
             setType(t, sourceTy.type);
             _ty = sourceTy;
@@ -1602,7 +1601,7 @@ public:
                     target->type = conversion.targetType;
                     Expr *convert = bb->CONVERT(*conversion.expr, conversion.targetType);
                     Move *convCall = f->New<Move>();
-                    convCall->init(target, convert, OpInvalid);
+                    convCall->init(target, convert);
 
                     Temp *source = bb->TEMP(target->index);
                     source->type = conversion.targetType;
@@ -2988,7 +2987,7 @@ void MoveMapping::insertMoves(BasicBlock *bb, Function *function, bool atEnd) co
     int insertionPoint = atEnd ? bb->statements.size() - 1 : 0;
     foreach (const Move &m, _moves) {
         V4IR::Move *move = function->New<V4IR::Move>();
-        move->init(m.to, m.from, OpInvalid);
+        move->init(m.to, m.from);
         move->id = m.id;
         move->swap = m.needsSwap;
         bb->statements.insert(insertionPoint++, move);