1 files changed, 21 insertions, 22 deletions

diff --git a/src/qml/jit/qv4unop.cpp b/src/qml/jit/qv4unop.cpp
index cb9131d731..6a32069ac4 100644
--- a/src/qml/jit/qv4unop.cpp
+++ b/src/qml/jit/qv4unop.cpp
@@ -47,11 +47,11 @@ using namespace JIT;
 #define stringIfyx(s) #s
 #define stringIfy(s) stringIfyx(s)
 #define setOp(operation) \
-    do { call = operation; name = stringIfy(operation); } while (0)
+    do { call = RuntimeCall(qOffsetOf(QV4::Runtime, operation)); name = "Runtime::" stringIfy(operation); } while (0)
 
 void Unop::generate(IR::Expr *source, IR::Expr *target)
 {
-    Runtime::UnaryOperation call = 0;
+    RuntimeCall call;
     const char *name = 0;
     switch (op) {
     case IR::OpNot:
@@ -60,19 +60,18 @@ void Unop::generate(IR::Expr *source, IR::Expr *target)
     case IR::OpUMinus:
         generateUMinus(source, target);
         return;
-    case IR::OpUPlus: setOp(Runtime::uPlus); break;
+    case IR::OpUPlus: setOp(uPlus); break;
     case IR::OpCompl:
         generateCompl(source, target);
         return;
-    case IR::OpIncrement: setOp(Runtime::increment); break;
-    case IR::OpDecrement: setOp(Runtime::decrement); break;
+    case IR::OpIncrement: setOp(increment); break;
+    case IR::OpDecrement: setOp(decrement); break;
     default:
         Q_UNREACHABLE();
     } // switch
 
-    if (call) {
-        as->generateFunctionCallImp(target, name, call, Assembler::PointerToValue(source));
-    }
+    Q_ASSERT(call.isValid());
+    _as->generateFunctionCallImp(target, name, call, Assembler::PointerToValue(source));
 }
 
 void Unop::generateUMinus(IR::Expr *source, IR::Expr *target)
@@ -82,15 +81,15 @@ void Unop::generateUMinus(IR::Expr *source, IR::Expr *target)
         Assembler::RegisterID tReg = Assembler::ScratchRegister;
         if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister)
             tReg = (Assembler::RegisterID) targetTemp->index;
-        Assembler::RegisterID sReg = as->toInt32Register(source, tReg);
-        as->move(sReg, tReg);
-        as->neg32(tReg);
+        Assembler::RegisterID sReg = _as->toInt32Register(source, tReg);
+        _as->move(sReg, tReg);
+        _as->neg32(tReg);
         if (!targetTemp || targetTemp->kind != IR::Temp::PhysicalRegister)
-            as->storeInt32(tReg, target);
+            _as->storeInt32(tReg, target);
         return;
     }
 
-    as->generateFunctionCallImp(target, "Runtime::uMinus", Runtime::uMinus, Assembler::PointerToValue(source));
+    generateRuntimeCall(target, uMinus, Assembler::PointerToValue(source));
 }
 
 void Unop::generateNot(IR::Expr *source, IR::Expr *target)
@@ -100,26 +99,26 @@ void Unop::generateNot(IR::Expr *source, IR::Expr *target)
         Assembler::RegisterID tReg = Assembler::ScratchRegister;
         if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister)
             tReg = (Assembler::RegisterID) targetTemp->index;
-        as->xor32(Assembler::TrustedImm32(0x1), as->toInt32Register(source, tReg), tReg);
+        _as->xor32(Assembler::TrustedImm32(0x1), _as->toInt32Register(source, tReg), tReg);
         if (!targetTemp || targetTemp->kind != IR::Temp::PhysicalRegister)
-            as->storeBool(tReg, target);
+            _as->storeBool(tReg, target);
         return;
     } else if (source->type == IR::SInt32Type) {
         Assembler::RegisterID tReg = Assembler::ScratchRegister;
         if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister)
             tReg = (Assembler::RegisterID) targetTemp->index;
-        as->compare32(Assembler::Equal,
-                      as->toInt32Register(source, Assembler::ScratchRegister), Assembler::TrustedImm32(0),
+        _as->compare32(Assembler::Equal,
+                      _as->toInt32Register(source, Assembler::ScratchRegister), Assembler::TrustedImm32(0),
                       tReg);
         if (!targetTemp || targetTemp->kind != IR::Temp::PhysicalRegister)
-            as->storeBool(tReg, target);
+            _as->storeBool(tReg, target);
         return;
     } else if (source->type == IR::DoubleType) {
         // ###
     }
     // ## generic implementation testing for int/bool
 
-    as->generateFunctionCallImp(target, "Runtime::uNot", Runtime::uNot, Assembler::PointerToValue(source));
+    generateRuntimeCall(target, uNot, Assembler::PointerToValue(source));
 }
 
 void Unop::generateCompl(IR::Expr *source, IR::Expr *target)
@@ -129,12 +128,12 @@ void Unop::generateCompl(IR::Expr *source, IR::Expr *target)
         Assembler::RegisterID tReg = Assembler::ScratchRegister;
         if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister)
             tReg = (Assembler::RegisterID) targetTemp->index;
-        as->xor32(Assembler::TrustedImm32(0xffffffff), as->toInt32Register(source, tReg), tReg);
+        _as->xor32(Assembler::TrustedImm32(0xffffffff), _as->toInt32Register(source, tReg), tReg);
         if (!targetTemp || targetTemp->kind != IR::Temp::PhysicalRegister)
-            as->storeInt32(tReg, target);
+            _as->storeInt32(tReg, target);
         return;
     }
-    as->generateFunctionCallImp(target, "Runtime::complement", Runtime::complement, Assembler::PointerToValue(source));
+    generateRuntimeCall(target, complement, Assembler::PointerToValue(source));
 }
 
 #endif