Inline unary operations in moth

Change-Id: I6e141a425c2b4cc0cd64c7f0011e7028b9147f69
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

4 files changed, 110 insertions, 27 deletions

diff --git a/src/qml/compiler/qv4instr_moth_p.h b/src/qml/compiler/qv4instr_moth_p.h
index 6eae11ae80..4c1fe360d1 100644
--- a/src/qml/compiler/qv4instr_moth_p.h
+++ b/src/qml/compiler/qv4instr_moth_p.h
@@ -93,7 +93,12 @@ QT_BEGIN_NAMESPACE
     F(CreateActivationProperty, createActivationProperty) \
     F(Jump, jump) \
     F(CJump, cjump) \
-    F(Unop, unop) \
+    F(UNot, unot) \
+    F(UPlus, uplus) \
+    F(UMinus, uminus) \
+    F(UCompl, ucompl) \
+    F(Increment, increment) \
+    F(Decrement, decrement) \
     F(Binop, binop) \
     F(BinopContext, binopContext) \
     F(AddNumberParams, addNumberParams) \
@@ -431,9 +436,33 @@ union Instr
         Param condition;
         bool invert;
     };
-    struct instr_unop {
+    struct instr_unot {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_uplus {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_uminus {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_ucompl {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_increment {
+        MOTH_INSTR_HEADER
+        Param source;
+        Param result;
+    };
+    struct instr_decrement {
         MOTH_INSTR_HEADER
-        QV4::UnaryOpName alu;
         Param source;
         Param result;
     };
@@ -518,7 +547,12 @@ union Instr
     instr_createActivationProperty createActivationProperty;
     instr_jump jump;
     instr_cjump cjump;
-    instr_unop unop;
+    instr_unot unot;
+    instr_uplus uplus;
+    instr_uminus uminus;
+    instr_ucompl ucompl;
+    instr_increment increment;
+    instr_decrement decrement;
     instr_binop binop;
     instr_binopContext binopContext;
     instr_addNumberParams addNumberParams;
diff --git a/src/qml/compiler/qv4isel_moth.cpp b/src/qml/compiler/qv4isel_moth.cpp
index b44ed164d7..a25da4d4ab 100644
--- a/src/qml/compiler/qv4isel_moth.cpp
+++ b/src/qml/compiler/qv4isel_moth.cpp
@@ -535,25 +535,54 @@ void InstructionSelection::unop(V4IR::AluOp oper, V4IR::Temp *sourceTemp, V4IR::
 
     QV4::UnaryOpName op = 0;
     switch (oper) {
-    case V4IR::OpIfTrue: assert(!"unreachable"); break;
-    case V4IR::OpNot: op = QV4::__qmljs_not; break;
-    case V4IR::OpUMinus: op = QV4::__qmljs_uminus; break;
-    case V4IR::OpUPlus: op = QV4::__qmljs_uplus; break;
-    case V4IR::OpCompl: op = QV4::__qmljs_compl; break;
-    case V4IR::OpIncrement: op = QV4::__qmljs_increment; break;
-    case V4IR::OpDecrement: op = QV4::__qmljs_decrement; break;
-    default: assert(!"unreachable"); break;
+    case V4IR::OpIfTrue:
+        Q_ASSERT(!"unreachable"); break;
+    case V4IR::OpNot: {
+        Instruction::UNot unot;
+        unot.source = getParam(sourceTemp);
+        unot.result = getResultParam(targetTemp);
+        addInstruction(unot);
+        return;
+    }
+    case V4IR::OpUMinus: {
+        Instruction::UMinus uminus;
+        uminus.source = getParam(sourceTemp);
+        uminus.result = getResultParam(targetTemp);
+        addInstruction(uminus);
+        return;
+    }
+    case V4IR::OpUPlus: {
+        Instruction::UPlus uplus;
+        uplus.source = getParam(sourceTemp);
+        uplus.result = getResultParam(targetTemp);
+        addInstruction(uplus);
+        return;
+    }
+    case V4IR::OpCompl: {
+        Instruction::UCompl ucompl;
+        ucompl.source = getParam(sourceTemp);
+        ucompl.result = getResultParam(targetTemp);
+        addInstruction(ucompl);
+        return;
+    }
+    case V4IR::OpIncrement: {
+        Instruction::Increment inc;
+        inc.source = getParam(sourceTemp);
+        inc.result = getResultParam(targetTemp);
+        addInstruction(inc);
+        return;
+    }
+    case V4IR::OpDecrement: {
+        Instruction::Decrement dec;
+        dec.source = getParam(sourceTemp);
+        dec.result = getResultParam(targetTemp);
+        addInstruction(dec);
+        return;
+    }
+    default:  break;
     } // switch
 
-    if (op) {
-        Instruction::Unop unop;
-        unop.alu = op;
-        unop.source = getParam(sourceTemp);
-        unop.result = getResultParam(targetTemp);
-        addInstruction(unop);
-    } else {
-        qWarning("  UNOP1");
-    }
+    Q_ASSERT(!"unreachable");
 }
 
 void InstructionSelection::binop(V4IR::AluOp oper, V4IR::Expr *leftSource, V4IR::Expr *rightSource, V4IR::Temp *target)
diff --git a/src/qml/jsruntime/qv4runtime_p.h b/src/qml/jsruntime/qv4runtime_p.h
index f61a9805ac..54ade9384b 100644
--- a/src/qml/jsruntime/qv4runtime_p.h
+++ b/src/qml/jsruntime/qv4runtime_p.h
@@ -262,10 +262,10 @@ inline QV4::ReturnedValue __qmljs_uplus(const QV4::ValueRef value)
 {
     TRACE1(value);
 
-    if (value->integerCompatible())
-        return Encode(value->int_32);
+    if (value->integerCompatible() || value->isDouble())
+        return value.asReturnedValue();
 
-    double n = value->toNumber();
+    double n = value->toNumberImpl();
     return Encode(n);
 }
 
diff --git a/src/qml/jsruntime/qv4vme_moth.cpp b/src/qml/jsruntime/qv4vme_moth.cpp
index 4de1d7a54c..bd4bd65911 100644
--- a/src/qml/jsruntime/qv4vme_moth.cpp
+++ b/src/qml/jsruntime/qv4vme_moth.cpp
@@ -472,9 +472,29 @@ QV4::ReturnedValue VME::run(QV4::ExecutionContext *context, const uchar *code,
             code = ((uchar *)&instr.offset) + instr.offset;
     MOTH_END_INSTR(CJump)
 
-    MOTH_BEGIN_INSTR(Unop)
-        STOREVALUE(instr.result, instr.alu(VALUEPTR(instr.source)));
-    MOTH_END_INSTR(Unop)
+    MOTH_BEGIN_INSTR(UNot)
+        STOREVALUE(instr.result, __qmljs_not(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(UNot)
+
+    MOTH_BEGIN_INSTR(UPlus)
+        STOREVALUE(instr.result, __qmljs_uplus(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(UPlus)
+
+    MOTH_BEGIN_INSTR(UMinus)
+        STOREVALUE(instr.result, __qmljs_uminus(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(UMinus)
+
+    MOTH_BEGIN_INSTR(UCompl)
+        STOREVALUE(instr.result, __qmljs_compl(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(UCompl)
+
+    MOTH_BEGIN_INSTR(Increment)
+        STOREVALUE(instr.result, __qmljs_increment(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(Increment)
+
+    MOTH_BEGIN_INSTR(Decrement)
+        STOREVALUE(instr.result, __qmljs_decrement(VALUEPTR(instr.source)));
+    MOTH_END_INSTR(Decrement)
 
     MOTH_BEGIN_INSTR(Binop)
         STOREVALUE(instr.result, instr.alu(VALUEPTR(instr.lhs), VALUEPTR(instr.rhs)));