V4: Clean up the runtime functions declarations

The declarations and usage of runtime functions have seen a number of
changes:
- we don't use the array of method pointers anymore because we don't use
  cross-platform AOT JITting
- the check if a method can throw a JS exception was invalid, and was
  not used anymore
- value-pointer vs. const-value-ref was inconsistent

This patch cleans that up. By fixing the exception checking, we can now
use it in the baseline JIT to automatically insert those checks. To make
that work correctly, all runtime methods are in a struct, which gets
annotated to indicate if that method throws. (The old way of checking
which type of engine was used is fragile: some non-throwing methods
do not take an engine parameter at all, and those got flagged as
throwing). By using a struct, we can also get rid of a bunch of
interesting macros.

The flags in the struct (as mentioned above) can later be extended to
capture more information, e.g. if a method will change the context.

Change-Id: I1e0b9ba62a0bf538eb728b4378e2678136e29a64
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

13 files changed, 846 insertions, 472 deletions

diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index 8637db3dfd..b975d02d9d 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -217,7 +217,7 @@ ReturnedValue ArrayPrototype::method_from(const FunctionObject *builtin, const V
         // Item iteration supported, so let's go ahead and try use that.
         ScopedObject a(createObjectFromCtorOrArray(scope, thatCtor, false, 0));
         CHECK_EXCEPTION();
-        ScopedObject iterator(scope, Runtime::method_getIterator(scope.engine, itemsObject, true));
+        ScopedObject iterator(scope, Runtime::GetIterator::call(scope.engine, itemsObject, true));
         CHECK_EXCEPTION(); // symbol_iterator threw; whoops.
         if (!iterator) {
             return scope.engine->throwTypeError(); // symbol_iterator wasn't an object.
@@ -234,11 +234,11 @@ ReturnedValue ArrayPrototype::method_from(const FunctionObject *builtin, const V
             if (k > (static_cast<qint64>(1) << 53) - 1) {
                 ScopedValue falsey(scope, Encode(false));
                 ScopedValue error(scope, scope.engine->throwTypeError());
-                return Runtime::method_iteratorClose(scope.engine, iterator, falsey);
+                return Runtime::IteratorClose::call(scope.engine, iterator, falsey);
             }
 
             // Retrieve the next value. If the iteration ends, we're done here.
-            done = Value::fromReturnedValue(Runtime::method_iteratorNext(scope.engine, iterator, nextValue));
+            done = Value::fromReturnedValue(Runtime::IteratorNext::call(scope.engine, iterator, nextValue));
             CHECK_EXCEPTION();
             if (done->toBoolean()) {
                 if (ArrayObject *ao = a->as<ArrayObject>()) {
@@ -255,7 +255,7 @@ ReturnedValue ArrayPrototype::method_from(const FunctionObject *builtin, const V
                 mapArguments[1] = Value::fromDouble(k);
                 mappedValue = mapfn->call(thisArg, mapArguments, 2);
                 if (scope.engine->hasException)
-                    return Runtime::method_iteratorClose(scope.engine, iterator, Value::fromBoolean(false));
+                    return Runtime::IteratorClose::call(scope.engine, iterator, Value::fromBoolean(false));
             } else {
                 mappedValue = *nextValue;
             }
@@ -269,7 +269,7 @@ ReturnedValue ArrayPrototype::method_from(const FunctionObject *builtin, const V
 
             if (scope.engine->hasException) {
                 ScopedValue falsey(scope, Encode(false));
-                return Runtime::method_iteratorClose(scope.engine, iterator, falsey);
+                return Runtime::IteratorClose::call(scope.engine, iterator, falsey);
             }
 
             k++;
@@ -385,7 +385,7 @@ ReturnedValue ArrayPrototype::method_toLocaleString(const FunctionObject *b, con
         v = instance->get(k);
         if (v->isNullOrUndefined())
             continue;
-        v = Runtime::method_callElement(scope.engine, v, *scope.engine->id_toLocaleString(), nullptr, 0);
+        v = Runtime::CallElement::call(scope.engine, v, *scope.engine->id_toLocaleString(), nullptr, 0);
         s = v->toString(scope.engine);
         if (scope.hasException())
             return Encode::undefined();
diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp
index 94b1a9fb73..b3bcfe21d5 100644
--- a/src/qml/jsruntime/qv4context.cpp
+++ b/src/qml/jsruntime/qv4context.cpp
@@ -81,17 +81,17 @@ Heap::CallContext *ExecutionContext::newBlockContext(CppStackFrame *frame, int b
     return c;
 }
 
-Heap::CallContext *ExecutionContext::cloneBlockContext(Heap::CallContext *context)
+Heap::CallContext *ExecutionContext::cloneBlockContext(ExecutionEngine *engine,
+                                                       Heap::CallContext *callContext)
 {
-    uint nLocals = context->locals.alloc;
+    uint nLocals = callContext->locals.alloc;
     size_t requiredMemory = sizeof(CallContext::Data) - sizeof(Value) + sizeof(Value) * nLocals;
 
-    ExecutionEngine *v4 = context->internalClass->engine;
-    Heap::CallContext *c = v4->memoryManager->allocManaged<CallContext>(requiredMemory, context->internalClass);
-    memcpy(c, context, requiredMemory);
+    Heap::CallContext *c = engine->memoryManager->allocManaged<CallContext>(
+                requiredMemory, callContext->internalClass);
+    memcpy(c, callContext, requiredMemory);
 
     return c;
-
 }
 
 Heap::CallContext *ExecutionContext::newCallContext(CppStackFrame *frame)
@@ -128,7 +128,7 @@ Heap::CallContext *ExecutionContext::newCallContext(CppStackFrame *frame)
     return c;
 }
 
-Heap::ExecutionContext *ExecutionContext::newWithContext(Heap::Object *with)
+Heap::ExecutionContext *ExecutionContext::newWithContext(Heap::Object *with) const
 {
     Heap::ExecutionContext *c = engine()->memoryManager->alloc<ExecutionContext>(Heap::ExecutionContext::Type_WithContext);
     c->outer.set(engine(), d());
diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h
index 5cd2f9ddf0..75fa2d08e6 100644
--- a/src/qml/jsruntime/qv4context_p.h
+++ b/src/qml/jsruntime/qv4context_p.h
@@ -150,9 +150,10 @@ struct Q_QML_EXPORT ExecutionContext : public Managed
     V4_INTERNALCLASS(ExecutionContext)
 
     static Heap::CallContext *newBlockContext(QV4::CppStackFrame *frame, int blockIndex);
-    static Heap::CallContext *cloneBlockContext(Heap::CallContext *context);
+    static Heap::CallContext *cloneBlockContext(ExecutionEngine *engine,
+                                                Heap::CallContext *callContext);
     static Heap::CallContext *newCallContext(QV4::CppStackFrame *frame);
-    Heap::ExecutionContext *newWithContext(Heap::Object *with);
+    Heap::ExecutionContext *newWithContext(Heap::Object *with) const;
     static Heap::ExecutionContext *newCatchContext(CppStackFrame *frame, int blockIndex, Heap::String *exceptionVarName);
 
     void createMutableBinding(String *name, bool deletable);
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 64c7e2f32b..4557f623d0 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -630,17 +630,6 @@ private:
     QScopedPointer<QV4::Promise::ReactionHandler> m_reactionHandler;
 };
 
-// This is a trick to tell the code generators that functions taking a NoThrowContext won't
-// throw exceptions and therefore don't need a check after the call.
-#ifndef V4_BOOTSTRAP
-struct NoThrowEngine : public ExecutionEngine
-{
-};
-#else
-struct NoThrowEngine;
-#endif
-
-
 #define CHECK_STACK_LIMITS(v4) if ((v4)->checkStackLimits()) return Encode::undefined(); \
     ExecutionEngineCallDepthRecorder _executionEngineCallDepthRecorder(v4);
 
diff --git a/src/qml/jsruntime/qv4mapobject.cpp b/src/qml/jsruntime/qv4mapobject.cpp
index 68741e7677..90e1908a84 100644
--- a/src/qml/jsruntime/qv4mapobject.cpp
+++ b/src/qml/jsruntime/qv4mapobject.cpp
@@ -80,7 +80,7 @@ ReturnedValue WeakMapCtor::construct(const FunctionObject *f, const Value *argv,
             if (!adder)
                 return scope.engine->throwTypeError();
 
-            ScopedObject iter(scope, Runtime::method_getIterator(scope.engine, iterable, true));
+            ScopedObject iter(scope, Runtime::GetIterator::call(scope.engine, iterable, true));
             if (scope.hasException())
                 return Encode::undefined();
             Q_ASSERT(iter);
@@ -89,7 +89,7 @@ ReturnedValue WeakMapCtor::construct(const FunctionObject *f, const Value *argv,
             Value *arguments = scope.alloc(2);
             ScopedValue done(scope);
             forever {
-                done = Runtime::method_iteratorNext(scope.engine, iter, obj);
+                done = Runtime::IteratorNext::call(scope.engine, iter, obj);
                 if (scope.hasException())
                     break;
                 if (done->toBoolean())
@@ -112,7 +112,7 @@ ReturnedValue WeakMapCtor::construct(const FunctionObject *f, const Value *argv,
                     break;
             }
             ScopedValue falsey(scope, Encode(false));
-            return Runtime::method_iteratorClose(scope.engine, iter, falsey);
+            return Runtime::IteratorClose::call(scope.engine, iter, falsey);
         }
     }
     return a->asReturnedValue();
diff --git a/src/qml/jsruntime/qv4promiseobject.cpp b/src/qml/jsruntime/qv4promiseobject.cpp
index 8450655334..b32e227b58 100644
--- a/src/qml/jsruntime/qv4promiseobject.cpp
+++ b/src/qml/jsruntime/qv4promiseobject.cpp
@@ -496,7 +496,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
     ScopedFunctionObject reject(scope, capability->d()->reject);
 
     ScopedObject itemsObject(scope, argv);
-    ScopedObject iteratorObject(scope, Runtime::method_getIterator(e, itemsObject, true));
+    ScopedObject iteratorObject(scope, Runtime::GetIterator::call(e, itemsObject, true));
     if (!iteratorObject || scope.hasException()) {
         ScopedObject error(scope);
         if (scope.hasException()) {
@@ -521,7 +521,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
     for (;;) {
         Scope scope(e);
         ScopedValue nextValue(scope);
-        doneValue = Value::fromReturnedValue(Runtime::method_iteratorNext(e, iteratorObject, nextValue));
+        doneValue = Value::fromReturnedValue(Runtime::IteratorNext::call(e, iteratorObject, nextValue));
 
         if (doneValue->toBoolean())
             break;
@@ -549,7 +549,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
             }
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(e, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(e, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
@@ -557,7 +557,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
 
         ScopedObject nextPromise(scope, Value::fromReturnedValue(resolve->call(thisObject, nextValue, 1)));
         if (!nextPromise || scope.hasException()) {
-            ScopedValue completion(scope, Runtime::method_iteratorClose(e, iteratorObject, doneValue));
+            ScopedValue completion(scope, Runtime::IteratorClose::call(e, iteratorObject, doneValue));
             if (scope.hasException()) {
                 completion = e->exceptionValue->asReturnedValue();
                 dropException(e);
@@ -579,7 +579,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
             }
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(scope.engine, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(scope.engine, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
@@ -598,7 +598,7 @@ ReturnedValue PromiseCtor::method_all(const FunctionObject *f, const Value *this
             dropException(e);
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(scope.engine, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(scope.engine, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
@@ -646,7 +646,7 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
     ScopedFunctionObject reject(scope, capability->d()->reject);
 
     ScopedObject itemsObject(scope, argv);
-    ScopedObject iteratorObject(scope, Runtime::method_getIterator(e, itemsObject, true));
+    ScopedObject iteratorObject(scope, Runtime::GetIterator::call(e, itemsObject, true));
     if (!iteratorObject) {
         ScopedObject error(scope, e->newTypeErrorObject(QStringLiteral("Type error")));
         reject->call(newPromise, error, 1);
@@ -657,10 +657,10 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
     for (;;) {
         Scope scope(e);
         ScopedValue nextValue(scope);
-        doneValue = Value::fromReturnedValue(Runtime::method_iteratorNext(e, iteratorObject, nextValue));
+        doneValue = Value::fromReturnedValue(Runtime::IteratorNext::call(e, iteratorObject, nextValue));
 
         if (scope.hasException()) {
-            ScopedValue completion(scope, Runtime::method_iteratorClose(e, iteratorObject, doneValue));
+            ScopedValue completion(scope, Runtime::IteratorClose::call(e, iteratorObject, doneValue));
             if (scope.hasException()) {
                 completion = e->exceptionValue->asReturnedValue();
                 dropException(e);
@@ -695,7 +695,7 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
             }
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(e, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(e, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
@@ -703,7 +703,7 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
 
         ScopedObject nextPromise(scope, Value::fromReturnedValue(resolve->call(thisObject, nextValue, 1)));
         if (!nextPromise || scope.hasException()) {
-            ScopedValue completion(scope, Runtime::method_iteratorClose(e, iteratorObject, doneValue));
+            ScopedValue completion(scope, Runtime::IteratorClose::call(e, iteratorObject, doneValue));
             if (scope.hasException()) {
                 completion = e->exceptionValue->asReturnedValue();
                 dropException(e);
@@ -723,7 +723,7 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
             }
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(e, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(e, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
@@ -742,7 +742,7 @@ ReturnedValue PromiseCtor::method_race(const FunctionObject *f, const Value *thi
             dropException(e);
 
             if (!doneValue->toBoolean())
-                completion = Runtime::method_iteratorClose(e, iteratorObject, doneValue);
+                completion = Runtime::IteratorClose::call(e, iteratorObject, doneValue);
 
             reject->call(newPromise, completion, 1);
             return newPromise.asReturnedValue();
diff --git a/src/qml/jsruntime/qv4reflect.cpp b/src/qml/jsruntime/qv4reflect.cpp
index 15dcb602eb..0772770d63 100644
--- a/src/qml/jsruntime/qv4reflect.cpp
+++ b/src/qml/jsruntime/qv4reflect.cpp
@@ -148,7 +148,7 @@ ReturnedValue Reflect::method_deleteProperty(const FunctionObject *f, const Valu
     if (!argc || !argv[0].isObject())
         return e->throwTypeError();
 
-    bool result =  Runtime::method_deleteProperty(e, argv[0], argc > 1 ? argv[1] : Value::undefinedValue());
+    bool result =  Runtime::DeleteProperty_NoThrow::call(e, argv[0], argc > 1 ? argv[1] : Value::undefinedValue());
     return Encode(result);
 }
 
diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index abf48b1034..310fa5282e 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -225,13 +225,6 @@ void RuntimeCounters::count(const char *func, uint tag1, uint tag2)
 
 #ifndef V4_BOOTSTRAP
 
-Runtime::Runtime()
-{
-#define INIT_METHOD(returnvalue, name, args) runtimeMethods[name] = reinterpret_cast<void*>(&method_##name);
-FOR_EACH_RUNTIME_METHOD(INIT_METHOD)
-#undef INIT_METHOD
-}
-
 void RuntimeHelpers::numberToString(QString *result, double num, int radix)
 {
     Q_ASSERT(result);
@@ -311,7 +304,7 @@ void RuntimeHelpers::numberToString(QString *result, double num, int radix)
         result->prepend(QLatin1Char('-'));
 }
 
-ReturnedValue Runtime::method_closure(ExecutionEngine *engine, int functionId)
+ReturnedValue Runtime::Closure::call(ExecutionEngine *engine, int functionId)
 {
     QV4::Function *clos = static_cast<CompiledData::CompilationUnit*>(engine->currentStackFrame->v4Function->compilationUnit)->runtimeFunctions[functionId];
     Q_ASSERT(clos);
@@ -321,7 +314,7 @@ ReturnedValue Runtime::method_closure(ExecutionEngine *engine, int functionId)
     return FunctionObject::createScriptFunction(current, clos)->asReturnedValue();
 }
 
-bool Runtime::method_deleteProperty(ExecutionEngine *engine, const Value &base, const Value &index)
+Bool Runtime::DeleteProperty_NoThrow::call(ExecutionEngine *engine, const Value &base, const Value &index)
 {
     Scope scope(engine);
     ScopedObject o(scope, base.toObject(engine));
@@ -335,14 +328,36 @@ bool Runtime::method_deleteProperty(ExecutionEngine *engine, const Value &base,
     return o->deleteProperty(key);
 }
 
-bool Runtime::method_deleteName(ExecutionEngine *engine, int nameIndex)
+ReturnedValue Runtime::DeleteProperty::call(ExecutionEngine *engine, QV4::Function *function, const QV4::Value &base, const QV4::Value &index)
+{
+    if (!Runtime::DeleteProperty_NoThrow::call(engine, base, index)) {
+        if (function->isStrict())
+            engine->throwTypeError();
+        return Encode(false);
+    } else {
+        return Encode(true);
+    }
+}
+
+Bool Runtime::DeleteName_NoThrow::call(ExecutionEngine *engine, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
     return static_cast<ExecutionContext &>(engine->currentStackFrame->jsFrame->context).deleteProperty(name);
 }
 
-QV4::ReturnedValue Runtime::method_instanceof(ExecutionEngine *engine, const Value &lval, const Value &rval)
+ReturnedValue Runtime::DeleteName::call(ExecutionEngine *engine, Function *function, int name)
+{
+    if (!Runtime::DeleteName_NoThrow::call(engine, name)) {
+        if (function->isStrict())
+            engine->throwTypeError();
+        return Encode(false);
+    } else {
+        return Encode(true);
+    }
+}
+
+QV4::ReturnedValue Runtime::Instanceof::call(ExecutionEngine *engine, const Value &lval, const Value &rval)
 {
     // 11.8.6, 5: rval must be an Object
     const Object *rhs = rval.as<Object>();
@@ -367,7 +382,7 @@ QV4::ReturnedValue Runtime::method_instanceof(ExecutionEngine *engine, const Val
     return Encode(result->toBoolean());
 }
 
-QV4::ReturnedValue Runtime::method_in(ExecutionEngine *engine, const Value &left, const Value &right)
+QV4::ReturnedValue Runtime::In::call(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     Object *ro = right.objectValue();
     if (!ro)
@@ -595,13 +610,12 @@ QV4::ReturnedValue RuntimeHelpers::addHelper(ExecutionEngine *engine, const Valu
     return Encode(x + y);
 }
 
-ReturnedValue RuntimeHelpers::getTemplateObject(Function *function, int index)
+ReturnedValue Runtime::GetTemplateObject::call(Function *function, int index)
 {
     return function->compilationUnit->templateObjectAt(index)->asReturnedValue();
 }
 
-
-void Runtime::method_storeProperty(ExecutionEngine *engine, const Value &object, int nameIndex, const Value &value)
+void Runtime::StoreProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex, const Value &value)
 {
     Scope scope(engine);
     QV4::Function *v4Function = engine->currentStackFrame->v4Function;
@@ -674,7 +688,7 @@ static Q_NEVER_INLINE ReturnedValue getElementFallback(ExecutionEngine *engine,
     return o->get(name);
 }
 
-ReturnedValue Runtime::method_loadElement(ExecutionEngine *engine, const Value &object, const Value &index)
+ReturnedValue Runtime::LoadElement::call(ExecutionEngine *engine, const Value &object, const Value &index)
 {
     if (index.isPositiveInt()) {
         uint idx = static_cast<uint>(index.int_32());
@@ -695,7 +709,7 @@ ReturnedValue Runtime::method_loadElement(ExecutionEngine *engine, const Value &
     return getElementFallback(engine, object, index);
 }
 
-ReturnedValue Runtime::method_loadElement_traced(ExecutionEngine *engine, const Value &object, const Value &index, quint8 *traceSlot)
+ReturnedValue Runtime::LoadElement_Traced::call(ExecutionEngine *engine, const Value &object, const Value &index, quint8 *traceSlot)
 {
     *traceSlot |= quint8(ObservedTraceValues::ArrayWasAccessed);
     if (index.isPositiveInt()) {
@@ -752,7 +766,7 @@ static Q_NEVER_INLINE bool setElementFallback(ExecutionEngine *engine, const Val
     return o->put(name, value);
 }
 
-void Runtime::method_storeElement(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
+void Runtime::StoreElement::call(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
 {
     if (index.isPositiveInt()) {
         uint idx = static_cast<uint>(index.int_32());
@@ -774,7 +788,7 @@ void Runtime::method_storeElement(ExecutionEngine *engine, const Value &object,
         engine->throwTypeError();
 }
 
-void Runtime::method_storeElement_traced(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value, quint8 *traceSlot)
+void Runtime::StoreElement_traced::call(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value, quint8 *traceSlot)
 {
     *traceSlot |= quint8(ObservedTraceValues::ArrayWasAccessed);
     if (index.isPositiveInt()) {
@@ -798,7 +812,7 @@ void Runtime::method_storeElement_traced(ExecutionEngine *engine, const Value &o
         engine->throwTypeError();
 }
 
-ReturnedValue Runtime::method_getIterator(ExecutionEngine *engine, const Value &in, int iterator)
+ReturnedValue Runtime::GetIterator::call(ExecutionEngine *engine, const Value &in, int iterator)
 {
     Scope scope(engine);
     ScopedObject o(scope, (Object *)nullptr);
@@ -821,7 +835,7 @@ ReturnedValue Runtime::method_getIterator(ExecutionEngine *engine, const Value &
     return engine->newForInIteratorObject(o)->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_iteratorNext(ExecutionEngine *engine, const Value &iterator, Value *value)
+ReturnedValue Runtime::IteratorNext::call(ExecutionEngine *engine, const Value &iterator, Value *value)
 {
     // if we throw an exception from here, return true, not undefined. This is to ensure iteratorDone is set to true
     // and the stack unwinding won't close the iterator
@@ -857,7 +871,7 @@ ReturnedValue Runtime::method_iteratorNext(ExecutionEngine *engine, const Value
     return Encode(false);
 }
 
-ReturnedValue Runtime::method_iteratorNextForYieldStar(ExecutionEngine *engine, const Value &received, const Value &iterator, Value *object)
+ReturnedValue Runtime::IteratorNextForYieldStar::call(ExecutionEngine *engine, const Value &received, const Value &iterator, Value *object)
 {
     // the return value encodes how to continue the yield* iteration.
     // true implies iteration is done, false for iteration to continue
@@ -894,7 +908,7 @@ ReturnedValue Runtime::method_iteratorNextForYieldStar(ExecutionEngine *engine,
             if (t->isUndefined()) {
                 // no throw method on the iterator
                 ScopedValue done(scope, Encode(false));
-                method_iteratorClose(engine, iterator, done);
+                IteratorClose::call(engine, iterator, done);
                 if (engine->hasException)
                     return Encode::undefined();
                 return engine->throwTypeError();
@@ -929,7 +943,7 @@ ReturnedValue Runtime::method_iteratorNextForYieldStar(ExecutionEngine *engine,
     return Encode(false);
 }
 
-ReturnedValue Runtime::method_iteratorClose(ExecutionEngine *engine, const Value &iterator, const Value &done)
+ReturnedValue Runtime::IteratorClose::call(ExecutionEngine *engine, const Value &iterator, const Value &done)
 {
     Q_ASSERT(iterator.isObject());
     Q_ASSERT(done.isBoolean());
@@ -969,7 +983,7 @@ ReturnedValue Runtime::method_iteratorClose(ExecutionEngine *engine, const Value
     return originalCompletion();
 }
 
-ReturnedValue Runtime::method_destructureRestElement(ExecutionEngine *engine, const Value &iterator)
+ReturnedValue Runtime::DestructureRestElement::call(ExecutionEngine *engine, const Value &iterator)
 {
     Q_ASSERT(iterator.isObject());
 
@@ -979,7 +993,7 @@ ReturnedValue Runtime::method_destructureRestElement(ExecutionEngine *engine, co
     uint index = 0;
     while (1) {
         ScopedValue n(scope);
-        ScopedValue done(scope, method_iteratorNext(engine, iterator, n));
+        ScopedValue done(scope, IteratorNext::call(engine, iterator, n));
         if (engine->hasException)
             return Encode::undefined();
         Q_ASSERT(done->isBoolean());
@@ -991,7 +1005,7 @@ ReturnedValue Runtime::method_destructureRestElement(ExecutionEngine *engine, co
     return array->asReturnedValue();
 }
 
-void Runtime::method_storeNameSloppy(ExecutionEngine *engine, int nameIndex, const Value &value)
+void Runtime::StoreNameSloppy::call(ExecutionEngine *engine, int nameIndex, const Value &value)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
@@ -1001,7 +1015,7 @@ void Runtime::method_storeNameSloppy(ExecutionEngine *engine, int nameIndex, con
         engine->globalObject->put(name, value);
 }
 
-void Runtime::method_storeNameStrict(ExecutionEngine *engine, int nameIndex, const Value &value)
+void Runtime::StoreNameStrict::call(ExecutionEngine *engine, int nameIndex, const Value &value)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
@@ -1012,7 +1026,7 @@ void Runtime::method_storeNameStrict(ExecutionEngine *engine, int nameIndex, con
         engine->throwReferenceError(name);
 }
 
-ReturnedValue Runtime::method_loadProperty(ExecutionEngine *engine, const Value &object, int nameIndex)
+ReturnedValue Runtime::LoadProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
@@ -1032,7 +1046,7 @@ ReturnedValue Runtime::method_loadProperty(ExecutionEngine *engine, const Value
     return o->get(name);
 }
 
-ReturnedValue Runtime::method_loadName(ExecutionEngine *engine, int nameIndex)
+ReturnedValue Runtime::LoadName::call(ExecutionEngine *engine, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
@@ -1075,7 +1089,7 @@ static Object *getSuperBase(Scope &scope)
     return proto;
 }
 
-ReturnedValue Runtime::method_loadSuperProperty(ExecutionEngine *engine, const Value &property)
+ReturnedValue Runtime::LoadSuperProperty::call(ExecutionEngine *engine, const Value &property)
 {
     Scope scope(engine);
     Object *base = getSuperBase(scope);
@@ -1087,7 +1101,7 @@ ReturnedValue Runtime::method_loadSuperProperty(ExecutionEngine *engine, const V
     return base->get(key, &engine->currentStackFrame->jsFrame->thisObject);
 }
 
-void Runtime::method_storeSuperProperty(ExecutionEngine *engine, const Value &property, const Value &value)
+void Runtime::StoreSuperProperty::call(ExecutionEngine *engine, const Value &property, const Value &value)
 {
     Scope scope(engine);
     Object *base = getSuperBase(scope);
@@ -1101,7 +1115,34 @@ void Runtime::method_storeSuperProperty(ExecutionEngine *engine, const Value &pr
         engine->throwTypeError();
 }
 
-ReturnedValue Runtime::method_loadSuperConstructor(ExecutionEngine *engine, const Value &t)
+ReturnedValue Runtime::LoadGlobalLookup::call(ExecutionEngine *engine, Function *f, int index)
+{
+    Lookup *l = f->compilationUnit->runtimeLookups + index;
+    return l->globalGetter(l, engine);
+}
+
+ReturnedValue Runtime::GetLookup::call(ExecutionEngine *engine, Function *f, const Value &base, int index)
+{
+    Lookup *l = f->compilationUnit->runtimeLookups + index;
+    return l->getter(l, engine, base);
+}
+
+void Runtime::SetLookupSloppy::call(Function *f, const Value &base, int index, const Value &value)
+{
+    ExecutionEngine *engine = f->internalClass->engine;
+    QV4::Lookup *l = f->compilationUnit->runtimeLookups + index;
+    l->setter(l, engine, const_cast<Value &>(base), value);
+}
+
+void Runtime::SetLookupStrict::call(Function *f, const Value &base, int index, const Value &value)
+{
+    ExecutionEngine *engine = f->internalClass->engine;
+    QV4::Lookup *l = f->compilationUnit->runtimeLookups + index;
+    if (!l->setter(l, engine, const_cast<Value &>(base), value))
+        engine->throwTypeError();
+}
+
+ReturnedValue Runtime::LoadSuperConstructor::call(ExecutionEngine *engine, const Value &t)
 {
     if (engine->currentStackFrame->thisObject() != Value::emptyValue().asReturnedValue()) {
         return engine->throwReferenceError(QStringLiteral("super() already called."), QString(), 0, 0); // ### fix line number
@@ -1134,9 +1175,9 @@ uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
         double dx = RuntimeHelpers::toNumber(x);
         return dx == y.asDouble();
     } else if (x.isBoolean()) {
-        return Runtime::method_compareEqual(Value::fromDouble((double) x.booleanValue()), y);
+        return Runtime::CompareEqual::call(Value::fromDouble((double) x.booleanValue()), y);
     } else if (y.isBoolean()) {
-        return Runtime::method_compareEqual(x, Value::fromDouble((double) y.booleanValue()));
+        return Runtime::CompareEqual::call(x, Value::fromDouble((double) y.booleanValue()));
     } else {
 #ifdef V4_BOOTSTRAP
         Q_UNIMPLEMENTED();
@@ -1146,11 +1187,11 @@ uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
         if (yo && (x.isNumber() || x.isString())) {
             Scope scope(yo->engine());
             ScopedValue py(scope, RuntimeHelpers::objectDefaultValue(yo, PREFERREDTYPE_HINT));
-            return Runtime::method_compareEqual(x, py);
+            return Runtime::CompareEqual::call(x, py);
         } else if (xo && (y.isNumber() || y.isString())) {
             Scope scope(xo->engine());
             ScopedValue px(scope, RuntimeHelpers::objectDefaultValue(xo, PREFERREDTYPE_HINT));
-            return Runtime::method_compareEqual(px, y);
+            return Runtime::CompareEqual::call(px, y);
         }
 #endif
     }
@@ -1173,7 +1214,7 @@ Bool RuntimeHelpers::strictEqual(const Value &x, const Value &y)
     return false;
 }
 
-QV4::Bool Runtime::method_compareGreaterThan(const Value &l, const Value &r)
+QV4::Bool Runtime::CompareGreaterThan::call(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -1201,7 +1242,7 @@ QV4::Bool Runtime::method_compareGreaterThan(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
         QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
-        return Runtime::method_compareGreaterThan(pl, pr);
+        return Runtime::CompareGreaterThan::call(pl, pr);
 #endif
     }
 
@@ -1210,7 +1251,7 @@ QV4::Bool Runtime::method_compareGreaterThan(const Value &l, const Value &r)
     return dl > dr;
 }
 
-QV4::Bool Runtime::method_compareLessThan(const Value &l, const Value &r)
+QV4::Bool Runtime::CompareLessThan::call(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -1238,7 +1279,7 @@ QV4::Bool Runtime::method_compareLessThan(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
         QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
-        return Runtime::method_compareLessThan(pl, pr);
+        return Runtime::CompareLessThan::call(pl, pr);
 #endif
     }
 
@@ -1247,7 +1288,7 @@ QV4::Bool Runtime::method_compareLessThan(const Value &l, const Value &r)
     return dl < dr;
 }
 
-QV4::Bool Runtime::method_compareGreaterEqual(const Value &l, const Value &r)
+QV4::Bool Runtime::CompareGreaterEqual::call(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -1275,7 +1316,7 @@ QV4::Bool Runtime::method_compareGreaterEqual(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
         QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
-        return Runtime::method_compareGreaterEqual(pl, pr);
+        return Runtime::CompareGreaterEqual::call(pl, pr);
 #endif
     }
 
@@ -1284,7 +1325,7 @@ QV4::Bool Runtime::method_compareGreaterEqual(const Value &l, const Value &r)
     return dl >= dr;
 }
 
-QV4::Bool Runtime::method_compareLessEqual(const Value &l, const Value &r)
+QV4::Bool Runtime::CompareLessEqual::call(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -1312,7 +1353,7 @@ QV4::Bool Runtime::method_compareLessEqual(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
         QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
-        return Runtime::method_compareLessEqual(pl, pr);
+        return Runtime::CompareLessEqual::call(pl, pr);
 #endif
     }
 
@@ -1322,26 +1363,26 @@ QV4::Bool Runtime::method_compareLessEqual(const Value &l, const Value &r)
 }
 
 #ifndef V4_BOOTSTRAP
-Bool Runtime::method_compareInstanceof(ExecutionEngine *engine, const Value &left, const Value &right)
+Bool Runtime::CompareInstanceof::call(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
     Scope scope(engine);
-    ScopedValue v(scope, method_instanceof(engine, left, right));
+    ScopedValue v(scope, Instanceof::call(engine, left, right));
     return v->booleanValue();
 }
 
-uint Runtime::method_compareIn(ExecutionEngine *engine, const Value &left, const Value &right)
+uint Runtime::CompareIn::call(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
     Scope scope(engine);
-    ScopedValue v(scope, method_in(engine, left, right));
+    ScopedValue v(scope, In::call(engine, left, right));
     return v->booleanValue();
 }
 
 
-ReturnedValue Runtime::method_callGlobalLookup(ExecutionEngine *engine, uint index, Value *argv, int argc)
+ReturnedValue Runtime::CallGlobalLookup::call(ExecutionEngine *engine, uint index, Value argv[], int argc)
 {
     Lookup *l = engine->currentStackFrame->v4Function->compilationUnit->runtimeLookups + index;
     Value function = Value::fromReturnedValue(l->globalGetter(l, engine));
@@ -1352,7 +1393,7 @@ ReturnedValue Runtime::method_callGlobalLookup(ExecutionEngine *engine, uint ind
     return static_cast<FunctionObject &>(function).call(&thisObject, argv, argc);
 }
 
-ReturnedValue Runtime::method_callPossiblyDirectEval(ExecutionEngine *engine, Value *argv, int argc)
+ReturnedValue Runtime::CallPossiblyDirectEval::call(ExecutionEngine *engine, Value *argv, int argc)
 {
     Scope scope(engine);
     ScopedValue thisObject(scope);
@@ -1376,7 +1417,7 @@ ReturnedValue Runtime::method_callPossiblyDirectEval(ExecutionEngine *engine, Va
     return function->call(thisObject, argv, argc);
 }
 
-ReturnedValue Runtime::method_callName(ExecutionEngine *engine, int nameIndex, Value *argv, int argc)
+ReturnedValue Runtime::CallName::call(ExecutionEngine *engine, int nameIndex, Value *argv, int argc)
 {
     Scope scope(engine);
     ScopedValue thisObject(scope);
@@ -1400,8 +1441,9 @@ ReturnedValue Runtime::method_callName(ExecutionEngine *engine, int nameIndex, V
     return f->call(thisObject, argv, argc);
 }
 
-ReturnedValue Runtime::method_callProperty(ExecutionEngine *engine, Value *base, int nameIndex, Value *argv, int argc)
+ReturnedValue Runtime::CallProperty::call(ExecutionEngine *engine, const Value &baseRef, int nameIndex, Value *argv, int argc)
 {
+    const Value *base = &baseRef;
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
     ScopedObject lookupObject(scope, base);
@@ -1415,7 +1457,7 @@ ReturnedValue Runtime::method_callProperty(ExecutionEngine *engine, Value *base,
         }
 
         if (base->isManaged()) {
-            Managed *m = static_cast<Managed *>(base);
+            const Managed *m = static_cast<const Managed *>(base);
             lookupObject = m->internalClass()->prototype;
             Q_ASSERT(m->internalClass()->prototype);
         } else {
@@ -1439,20 +1481,21 @@ ReturnedValue Runtime::method_callProperty(ExecutionEngine *engine, Value *base,
     return f->call(base, argv, argc);
 }
 
-ReturnedValue Runtime::method_callPropertyLookup(ExecutionEngine *engine, Value *base, uint index, Value *argv, int argc)
+ReturnedValue Runtime::CallPropertyLookup::call(ExecutionEngine *engine, const Value &base, uint index, Value *argv, int argc)
 {
     Lookup *l = engine->currentStackFrame->v4Function->compilationUnit->runtimeLookups + index;
     // ok to have the value on the stack here
-    Value f = Value::fromReturnedValue(l->getter(l, engine, *base));
+    Value f = Value::fromReturnedValue(l->getter(l, engine, base));
 
     if (!f.isFunctionObject())
         return engine->throwTypeError();
 
-    return static_cast<FunctionObject &>(f).call(base, argv, argc);
+    return static_cast<FunctionObject &>(f).call(&base, argv, argc);
 }
 
-ReturnedValue Runtime::method_callElement(ExecutionEngine *engine, Value *base, const Value &index, Value *argv, int argc)
+ReturnedValue Runtime::CallElement::call(ExecutionEngine *engine, const Value &baseRef, const Value &index, Value *argv, int argc)
 {
+    const Value *base = &baseRef;
     Scope scope(engine);
     ScopedValue thisObject(scope, base->toObject(engine));
     base = thisObject;
@@ -1461,14 +1504,14 @@ ReturnedValue Runtime::method_callElement(ExecutionEngine *engine, Value *base,
     if (engine->hasException)
         return Encode::undefined();
 
-    ScopedFunctionObject f(scope, static_cast<Object *>(base)->get(str));
+    ScopedFunctionObject f(scope, static_cast<const Object *>(base)->get(str));
     if (!f)
         return engine->throwTypeError();
 
     return f->call(base, argv, argc);
 }
 
-ReturnedValue Runtime::method_callValue(ExecutionEngine *engine, const Value &func, Value *argv, int argc)
+ReturnedValue Runtime::CallValue::call(ExecutionEngine *engine, const Value &func, Value *argv, int argc)
 {
     if (!func.isFunctionObject())
         return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
@@ -1476,41 +1519,45 @@ ReturnedValue Runtime::method_callValue(ExecutionEngine *engine, const Value &fu
     return static_cast<const FunctionObject &>(func).call(&undef, argv, argc);
 }
 
-ReturnedValue Runtime::method_callWithReceiver(ExecutionEngine *engine, const Value &func, const Value *thisObject, Value *argv, int argc)
+ReturnedValue Runtime::CallWithReceiver::call(ExecutionEngine *engine, const Value &func,
+                                               const Value &thisObject, Value argv[], int argc)
 {
     if (!func.isFunctionObject())
         return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
-    return static_cast<const FunctionObject &>(func).call(thisObject, argv, argc);
+    return static_cast<const FunctionObject &>(func).call(&thisObject, argv, argc);
 }
 
-ReturnedValue Runtime::method_callQmlScopeObjectProperty(ExecutionEngine *engine, Value *base,
-                                                         int propertyIndex, Value *argv, int argc)
+ReturnedValue Runtime::CallQmlScopeObjectProperty::call(ExecutionEngine *engine, const Value &base,
+                                                         int propertyIndex, Value argv[], int argc)
 {
     Scope scope(engine);
-    ScopedFunctionObject fo(scope, method_loadQmlScopeObjectProperty(engine, *base, propertyIndex,
-                                                                     /*captureRequired*/true));
+    ScopedFunctionObject fo(scope, LoadQmlScopeObjectProperty::call(engine, base, propertyIndex,
+                                                                    /*captureRequired*/true));
     if (!fo) {
         QString error = QStringLiteral("Property '%1' of scope object is not a function").arg(propertyIndex);
         return engine->throwTypeError(error);
     }
 
-    QObject *qmlScopeObj = static_cast<QmlContext *>(base)->d()->qml()->scopeObject;
+    QObject *qmlScopeObj = static_cast<const QmlContext *>(&base)->d()->qml()->scopeObject;
     ScopedValue qmlScopeValue(scope, QObjectWrapper::wrap(engine, qmlScopeObj));
     return fo->call(qmlScopeValue, argv, argc);
 }
 
-ReturnedValue Runtime::method_callQmlContextObjectProperty(ExecutionEngine *engine, Value *base,
-                                                           int propertyIndex, Value *argv, int argc)
+ReturnedValue Runtime::CallQmlContextObjectProperty::call(ExecutionEngine *engine,
+                                                           const Value &base,
+                                                           int propertyIndex,
+                                                           Value argv[],
+                                                           int argc)
 {
     Scope scope(engine);
-    ScopedFunctionObject fo(scope, method_loadQmlContextObjectProperty(engine, *base, propertyIndex,
-                                                                       /*captureRequired*/true));
+    ScopedFunctionObject fo(scope, LoadQmlContextObjectProperty::call(engine, base, propertyIndex,
+                                                                      /*captureRequired*/true));
     if (!fo) {
         QString error = QStringLiteral("Property '%1' of context object is not a function").arg(propertyIndex);
         return engine->throwTypeError(error);
     }
 
-    QObject *qmlContextObj = static_cast<QmlContext *>(base)->d()->qml()->context->contextData()->contextObject;
+    QObject *qmlContextObj = static_cast<const QmlContext *>(&base)->d()->qml()->context->contextData()->contextObject;
     ScopedValue qmlContextValue(scope, QObjectWrapper::wrap(engine, qmlContextObj));
     return fo->call(qmlContextValue, argv, argc);
 }
@@ -1538,11 +1585,11 @@ static CallArgs createSpreadArguments(Scope &scope, Value *argv, int argc)
         }
         // spread element
         ++i;
-        it = Runtime::method_getIterator(scope.engine, argv[i], /* ForInIterator */ 1);
+        it = Runtime::GetIterator::call(scope.engine, argv[i], /* ForInIterator */ 1);
         if (scope.engine->hasException)
             return { nullptr, 0 };
         while (1) {
-            done = Runtime::method_iteratorNext(scope.engine, it, v);
+            done = Runtime::IteratorNext::call(scope.engine, it, v);
             if (scope.engine->hasException)
                 return { nullptr, 0 };
             Q_ASSERT(done->isBoolean());
@@ -1555,7 +1602,7 @@ static CallArgs createSpreadArguments(Scope &scope, Value *argv, int argc)
     return { arguments, argCount };
 }
 
-ReturnedValue Runtime::method_callWithSpread(ExecutionEngine *engine, const Value &function, const Value &thisObject, Value *argv, int argc)
+ReturnedValue Runtime::CallWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &thisObject, Value *argv, int argc)
 {
     Q_ASSERT(argc >= 1);
     if (!function.isFunctionObject())
@@ -1569,7 +1616,7 @@ ReturnedValue Runtime::method_callWithSpread(ExecutionEngine *engine, const Valu
     return static_cast<const FunctionObject &>(function).call(&thisObject, arguments.argv, arguments.argc);
 }
 
-ReturnedValue Runtime::method_construct(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
+ReturnedValue Runtime::Construct::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
 {
     if (!function.isFunctionObject())
         return engine->throwTypeError();
@@ -1577,7 +1624,7 @@ ReturnedValue Runtime::method_construct(ExecutionEngine *engine, const Value &fu
     return static_cast<const FunctionObject &>(function).callAsConstructor(argv, argc, &newTarget);
 }
 
-ReturnedValue Runtime::method_constructWithSpread(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
+ReturnedValue Runtime::ConstructWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
 {
     if (!function.isFunctionObject())
         return engine->throwTypeError();
@@ -1590,7 +1637,7 @@ ReturnedValue Runtime::method_constructWithSpread(ExecutionEngine *engine, const
     return static_cast<const FunctionObject &>(function).callAsConstructor(arguments.argv, arguments.argc, &newTarget);
 }
 
-ReturnedValue Runtime::method_tailCall(CppStackFrame *frame, ExecutionEngine *engine)
+ReturnedValue Runtime::TailCall::call(CppStackFrame *frame, ExecutionEngine *engine)
 {
     // IMPORTANT! The JIT assumes that this method has the same amount (or less) arguments than
     // the jitted function, so it can safely do a tail call.
@@ -1618,13 +1665,13 @@ ReturnedValue Runtime::method_tailCall(CppStackFrame *frame, ExecutionEngine *en
     return Encode::undefined();
 }
 
-void Runtime::method_throwException(ExecutionEngine *engine, const Value &value)
+void Runtime::ThrowException::call(ExecutionEngine *engine, const Value &value)
 {
     if (!value.isEmpty())
         engine->throwError(value);
 }
 
-ReturnedValue Runtime::method_typeofValue(ExecutionEngine *engine, const Value &value)
+ReturnedValue Runtime::TypeofValue::call(ExecutionEngine *engine, const Value &value)
 {
     Scope scope(engine);
     ScopedString res(scope);
@@ -1655,83 +1702,109 @@ ReturnedValue Runtime::method_typeofValue(ExecutionEngine *engine, const Value &
     return res.asReturnedValue();
 }
 
-QV4::ReturnedValue Runtime::method_typeofName(ExecutionEngine *engine, int nameIndex)
+QV4::ReturnedValue Runtime::TypeofName::call(ExecutionEngine *engine, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
     ScopedValue prop(scope, static_cast<ExecutionContext &>(engine->currentStackFrame->jsFrame->context).getProperty(name));
     // typeof doesn't throw. clear any possible exception
     scope.engine->hasException = false;
-    return method_typeofValue(engine, prop);
+    return TypeofValue::call(engine, prop);
 }
 
-ReturnedValue Runtime::method_createWithContext(ExecutionEngine *engine, Value *jsStackFrame)
+void Runtime::PushCallContext::call(CppStackFrame *frame)
 {
-    QV4::Value &accumulator = jsStackFrame[CallData::Accumulator];
-    accumulator = accumulator.toObject(engine);
-    if (engine->hasException)
-        return Encode::undefined();
-    Q_ASSERT(accumulator.isObject());
-    const Object &obj = static_cast<const Object &>(accumulator);
-    ExecutionContext *context = static_cast<ExecutionContext *>(jsStackFrame + CallData::Context);
-    return context->newWithContext(obj.d())->asReturnedValue();
+    frame->jsFrame->context = ExecutionContext::newCallContext(frame)->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_createCatchContext(ExecutionContext *parent, int blockIndex, int exceptionVarNameIndex)
+ReturnedValue Runtime::PushWithContext::call(ExecutionEngine *engine, const Value &acc)
 {
-    ExecutionEngine *e = parent->engine();
-    return parent->newCatchContext(e->currentStackFrame, blockIndex,
-                                   e->currentStackFrame->v4Function->compilationUnit->runtimeStrings[exceptionVarNameIndex])->asReturnedValue();
+    CallData *jsFrame = engine->currentStackFrame->jsFrame;
+    Value &newAcc = jsFrame->accumulator;
+    newAcc = Value::fromHeapObject(acc.toObject(engine));
+    if (!engine->hasException) {
+        Q_ASSERT(newAcc.isObject());
+        const Object &obj = static_cast<const Object &>(newAcc);
+        Value &context = jsFrame->context;
+        auto ec = static_cast<const ExecutionContext *>(&context);
+        context = ec->newWithContext(obj.d())->asReturnedValue();
+    }
+    return newAcc.asReturnedValue();
 }
 
-ReturnedValue Runtime::method_createBlockContext(ExecutionContext *parent, int index)
+void Runtime::PushCatchContext::call(ExecutionEngine *engine, int blockIndex, int exceptionVarNameIndex)
 {
-    ExecutionEngine *e = parent->engine();
-    return parent->newBlockContext(e->currentStackFrame, index)->asReturnedValue();
+    auto name = engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[exceptionVarNameIndex];
+    engine->currentStackFrame->jsFrame->context = ExecutionContext::newCatchContext(engine->currentStackFrame, blockIndex, name)->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_cloneBlockContext(ExecutionContext *previous)
+void Runtime::PushBlockContext::call(ExecutionEngine *engine, int index)
 {
-    return ExecutionContext::cloneBlockContext(static_cast<Heap::CallContext *>(previous->d()))->asReturnedValue();
+    engine->currentStackFrame->jsFrame->context = ExecutionContext::newBlockContext(engine->currentStackFrame, index)->asReturnedValue();
 }
 
+void Runtime::CloneBlockContext::call(ExecutionEngine *engine)
+{
+    auto frame = engine->currentStackFrame;
+    auto context = static_cast<Heap::CallContext *>(frame->jsFrame->context.m());
+    frame->jsFrame->context =
+            ExecutionContext::cloneBlockContext(engine, context)->asReturnedValue();
+}
 
-ReturnedValue Runtime::method_createScriptContext(ExecutionEngine *engine, int index)
+void Runtime::PushScriptContext::call(ExecutionEngine *engine, int index)
 {
     Q_ASSERT(engine->currentStackFrame->context()->d()->type == Heap::ExecutionContext::Type_GlobalContext ||
              engine->currentStackFrame->context()->d()->type == Heap::ExecutionContext::Type_QmlContext);
     ReturnedValue c = ExecutionContext::newBlockContext(engine->currentStackFrame, index)->asReturnedValue();
     engine->setScriptContext(c);
-    return c;
+    engine->currentStackFrame->jsFrame->context = c;
 }
 
-ReturnedValue Runtime::method_popScriptContext(ExecutionEngine *engine)
+void Runtime::PopScriptContext::call(ExecutionEngine *engine)
 {
     ReturnedValue root = engine->rootContext()->asReturnedValue();
     engine->setScriptContext(root);
-    return root;
+    engine->currentStackFrame->jsFrame->context = root;
 }
 
-void Runtime::method_throwReferenceError(ExecutionEngine *engine, int nameIndex)
+void Runtime::ThrowReferenceError::call(ExecutionEngine *engine, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
     engine->throwReferenceError(name);
 }
 
-void Runtime::method_declareVar(ExecutionEngine *engine, bool deletable, int nameIndex)
+void Runtime::ThrowOnNullOrUndefined::call(ExecutionEngine *engine, const Value &v)
+{
+    if (v.isNullOrUndefined())
+        engine->throwTypeError();
+}
+
+ReturnedValue Runtime::ConvertThisToObject::call(ExecutionEngine *engine, const Value &t)
+{
+    if (!t.isObject()) {
+        if (t.isNullOrUndefined()) {
+            return engine->globalObject->asReturnedValue();
+        } else {
+            return t.toObject(engine)->asReturnedValue();
+        }
+    }
+    return t.asReturnedValue();
+}
+
+void Runtime::DeclareVar::call(ExecutionEngine *engine, Bool deletable, int nameIndex)
 {
     Scope scope(engine);
     ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
     static_cast<ExecutionContext &>(engine->currentStackFrame->jsFrame->context).createMutableBinding(name, deletable);
 }
 
-ReturnedValue Runtime::method_arrayLiteral(ExecutionEngine *engine, Value *values, uint length)
+ReturnedValue Runtime::ArrayLiteral::call(ExecutionEngine *engine, Value *values, uint length)
 {
     return engine->newArrayObject(values, length)->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_objectLiteral(ExecutionEngine *engine, int classId, const QV4::Value *args, int argc)
+ReturnedValue Runtime::ObjectLiteral::call(ExecutionEngine *engine, int classId, QV4::Value args[], int argc)
 {
     Scope scope(engine);
     Scoped<InternalClass> klass(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeClasses[classId]);
@@ -1804,7 +1877,8 @@ ReturnedValue Runtime::method_objectLiteral(ExecutionEngine *engine, int classId
     return o.asReturnedValue();
 }
 
-ReturnedValue Runtime::method_createClass(ExecutionEngine *engine, int classIndex, const Value &superClass, const Value *computedNames)
+ReturnedValue Runtime::CreateClass::call(ExecutionEngine *engine, int classIndex,
+                                          const Value &superClass, Value computedNames[])
 {
     const CompiledData::CompilationUnit *unit = engine->currentStackFrame->v4Function->compilationUnit;
     const QV4::CompiledData::Class *cls = unit->unitData()->classAt(classIndex);
@@ -1906,20 +1980,20 @@ ReturnedValue Runtime::method_createClass(ExecutionEngine *engine, int classInde
     return constructor->asReturnedValue();
 }
 
-QV4::ReturnedValue Runtime::method_createMappedArgumentsObject(ExecutionEngine *engine)
+QV4::ReturnedValue Runtime::CreateMappedArgumentsObject::call(ExecutionEngine *engine)
 {
     Q_ASSERT(engine->currentContext()->d()->type == Heap::ExecutionContext::Type_CallContext);
     Heap::InternalClass *ic = engine->internalClasses(EngineBase::Class_ArgumentsObject);
     return engine->memoryManager->allocObject<ArgumentsObject>(ic, engine->currentStackFrame)->asReturnedValue();
 }
 
-QV4::ReturnedValue Runtime::method_createUnmappedArgumentsObject(ExecutionEngine *engine)
+QV4::ReturnedValue Runtime::CreateUnmappedArgumentsObject::call(ExecutionEngine *engine)
 {
     Heap::InternalClass *ic = engine->internalClasses(EngineBase::Class_StrictArgumentsObject);
     return engine->memoryManager->allocObject<StrictArgumentsObject>(ic, engine->currentStackFrame)->asReturnedValue();
 }
 
-QV4::ReturnedValue Runtime::method_createRestParameter(ExecutionEngine *engine, int argIndex)
+QV4::ReturnedValue Runtime::CreateRestParameter::call(ExecutionEngine *engine, int argIndex)
 {
     const Value *values = engine->currentStackFrame->originalArguments + argIndex;
     int nValues = engine->currentStackFrame->originalArgumentsCount - argIndex;
@@ -1929,32 +2003,32 @@ QV4::ReturnedValue Runtime::method_createRestParameter(ExecutionEngine *engine,
 }
 
 
-ReturnedValue Runtime::method_loadQmlContext(NoThrowEngine *engine)
+ReturnedValue Runtime::LoadQmlContext::call(ExecutionEngine *engine)
 {
     Heap::QmlContext *ctx = engine->qmlContext();
     Q_ASSERT(ctx);
     return ctx->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_regexpLiteral(ExecutionEngine *engine, int id)
+ReturnedValue Runtime::RegexpLiteral::call(ExecutionEngine *engine, int id)
 {
     Heap::RegExpObject *ro = engine->newRegExpObject(engine->currentStackFrame->v4Function->compilationUnit->runtimeRegularExpressions[id].as<RegExp>());
     return ro->asReturnedValue();
 }
 
-ReturnedValue Runtime::method_loadQmlScopeObjectProperty(ExecutionEngine *engine, const Value &context, int propertyIndex, bool captureRequired)
+ReturnedValue Runtime::LoadQmlScopeObjectProperty::call(ExecutionEngine *engine, const Value &context, int propertyIndex, Bool captureRequired)
 {
     const QmlContext &c = static_cast<const QmlContext &>(context);
     return QV4::QObjectWrapper::getProperty(engine, c.d()->qml()->scopeObject, propertyIndex, captureRequired);
 }
 
-ReturnedValue Runtime::method_loadQmlContextObjectProperty(ExecutionEngine *engine, const Value &context, int propertyIndex, bool captureRequired)
+ReturnedValue Runtime::LoadQmlContextObjectProperty::call(ExecutionEngine *engine, const Value &context, int propertyIndex, Bool captureRequired)
 {
     const QmlContext &c = static_cast<const QmlContext &>(context);
     return QV4::QObjectWrapper::getProperty(engine, (*c.d()->qml()->context)->contextObject, propertyIndex, captureRequired);
 }
 
-ReturnedValue Runtime::method_loadQmlIdObject(ExecutionEngine *engine, const Value &c, uint index)
+ReturnedValue Runtime::LoadQmlIdObject::call(ExecutionEngine *engine, const Value &c, uint index)
 {
     const QmlContext &qmlContext = static_cast<const QmlContext &>(c);
     QQmlContextData *context = *qmlContext.d()->qml()->context;
@@ -1968,28 +2042,46 @@ ReturnedValue Runtime::method_loadQmlIdObject(ExecutionEngine *engine, const Val
     return QObjectWrapper::wrap(engine, context->idValues[index].data());
 }
 
-void Runtime::method_storeQmlScopeObjectProperty(ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)
+void Runtime::StoreQmlScopeObjectProperty::call(ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)
 {
     const QmlContext &c = static_cast<const QmlContext &>(context);
     return QV4::QObjectWrapper::setProperty(engine, c.d()->qml()->scopeObject, propertyIndex, value);
 }
 
-void Runtime::method_storeQmlContextObjectProperty(ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)
+void Runtime::StoreQmlContextObjectProperty::call(ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)
 {
     const QmlContext &c = static_cast<const QmlContext &>(context);
     return QV4::QObjectWrapper::setProperty(engine, (*c.d()->qml()->context)->contextObject, propertyIndex, value);
 }
 
-ReturnedValue Runtime::method_loadQmlImportedScripts(NoThrowEngine *engine)
+ReturnedValue Runtime::LoadQmlImportedScripts::call(ExecutionEngine *engine)
 {
     QQmlContextData *context = engine->callingQmlContext();
     if (!context)
         return Encode::undefined();
     return context->importedScripts.value();
 }
+
+ReturnedValue Runtime::ToObject::call(ExecutionEngine *engine, const Value &obj)
+{
+    if (obj.isObject())
+        return obj.asReturnedValue();
+
+    return obj.toObject(engine)->asReturnedValue();
+}
+
+Bool Runtime::ToBoolean::call(const Value &obj)
+{
+    return obj.toBoolean();
+}
+
+ReturnedValue Runtime::ToNumber::call(ExecutionEngine *, const Value &v)
+{
+    return Encode(v.toNumber());
+}
 #endif // V4_BOOTSTRAP
 
-ReturnedValue Runtime::method_uMinus(const Value &value)
+ReturnedValue Runtime::UMinus::call(const Value &value)
 {
     TRACE1(value);
 
@@ -2006,7 +2098,7 @@ ReturnedValue Runtime::method_uMinus(const Value &value)
 // binary operators
 
 #ifndef V4_BOOTSTRAP
-ReturnedValue Runtime::method_add(ExecutionEngine *engine, const Value &left, const Value &right)
+ReturnedValue Runtime::Add::call(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2018,7 +2110,7 @@ ReturnedValue Runtime::method_add(ExecutionEngine *engine, const Value &left, co
     return RuntimeHelpers::addHelper(engine, left, right);
 }
 
-ReturnedValue Runtime::method_sub(const Value &left, const Value &right)
+ReturnedValue Runtime::Sub::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2031,7 +2123,7 @@ ReturnedValue Runtime::method_sub(const Value &left, const Value &right)
     return Value::fromDouble(lval - rval).asReturnedValue();
 }
 
-ReturnedValue Runtime::method_mul(const Value &left, const Value &right)
+ReturnedValue Runtime::Mul::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2044,7 +2136,7 @@ ReturnedValue Runtime::method_mul(const Value &left, const Value &right)
     return Value::fromDouble(lval * rval).asReturnedValue();
 }
 
-ReturnedValue Runtime::method_div(const Value &left, const Value &right)
+ReturnedValue Runtime::Div::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2064,7 +2156,7 @@ ReturnedValue Runtime::method_div(const Value &left, const Value &right)
     return Value::fromDouble(lval / rval).asReturnedValue();
 }
 
-ReturnedValue Runtime::method_mod(const Value &left, const Value &right)
+ReturnedValue Runtime::Mod::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2085,7 +2177,43 @@ ReturnedValue Runtime::method_mod(const Value &left, const Value &right)
     return Value::fromDouble(std::fmod(lval, rval)).asReturnedValue();
 }
 
-ReturnedValue Runtime::method_shl(const Value &left, const Value &right)
+ReturnedValue Runtime::Exp::call(const Value &base, const Value &exp)
+{
+    double b = base.toNumber();
+    double e = exp.toNumber();
+    if (qt_is_inf(e) && (b == 1 || b == -1))
+        return Encode(qt_snan());
+    return Encode(pow(b,e));
+}
+
+ReturnedValue Runtime::BitAnd::call(const Value &left, const Value &right)
+{
+    TRACE2(left, right);
+
+    int lval = left.toInt32();
+    int rval = right.toInt32();
+    return Encode((int)(lval & rval));
+}
+
+ReturnedValue Runtime::BitOr::call(const Value &left, const Value &right)
+{
+    TRACE2(left, right);
+
+    int lval = left.toInt32();
+    int rval = right.toInt32();
+    return Encode((int)(lval | rval));
+}
+
+ReturnedValue Runtime::BitXor::call(const Value &left, const Value &right)
+{
+    TRACE2(left, right);
+
+    int lval = left.toInt32();
+    int rval = right.toInt32();
+    return Encode((int)(lval ^ rval));
+}
+
+ReturnedValue Runtime::Shl::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2094,7 +2222,7 @@ ReturnedValue Runtime::method_shl(const Value &left, const Value &right)
     return Encode((int)(lval << rval));
 }
 
-ReturnedValue Runtime::method_shr(const Value &left, const Value &right)
+ReturnedValue Runtime::Shr::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2103,7 +2231,7 @@ ReturnedValue Runtime::method_shr(const Value &left, const Value &right)
     return Encode((int)(lval >> rval));
 }
 
-ReturnedValue Runtime::method_ushr(const Value &left, const Value &right)
+ReturnedValue Runtime::UShr::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2116,35 +2244,35 @@ ReturnedValue Runtime::method_ushr(const Value &left, const Value &right)
 
 #endif // V4_BOOTSTRAP
 
-ReturnedValue Runtime::method_greaterThan(const Value &left, const Value &right)
+ReturnedValue Runtime::GreaterThan::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = method_compareGreaterThan(left, right);
+    bool r = CompareGreaterThan::call(left, right);
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_lessThan(const Value &left, const Value &right)
+ReturnedValue Runtime::LessThan::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = method_compareLessThan(left, right);
+    bool r = CompareLessThan::call(left, right);
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_greaterEqual(const Value &left, const Value &right)
+ReturnedValue Runtime::GreaterEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = method_compareGreaterEqual(left, right);
+    bool r = CompareGreaterEqual::call(left, right);
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_lessEqual(const Value &left, const Value &right)
+ReturnedValue Runtime::LessEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = method_compareLessEqual(left, right);
+    bool r = CompareLessEqual::call(left, right);
     return Encode(r);
 }
 
@@ -2168,7 +2296,7 @@ struct LazyScope
     }
 };
 
-Bool Runtime::method_compareEqual(const Value &left, const Value &right)
+Bool Runtime::CompareEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2277,23 +2405,23 @@ Bool Runtime::method_compareEqual(const Value &left, const Value &right)
     }
 }
 
-ReturnedValue Runtime::method_equal(const Value &left, const Value &right)
+ReturnedValue Runtime::Equal::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = method_compareEqual(left, right);
+    bool r = CompareEqual::call(left, right);
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_notEqual(const Value &left, const Value &right)
+ReturnedValue Runtime::NotEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = !method_compareEqual(left, right);
+    bool r = !CompareEqual::call(left, right);
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_strictEqual(const Value &left, const Value &right)
+ReturnedValue Runtime::StrictEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2301,7 +2429,7 @@ ReturnedValue Runtime::method_strictEqual(const Value &left, const Value &right)
     return Encode(r);
 }
 
-ReturnedValue Runtime::method_strictNotEqual(const Value &left, const Value &right)
+ReturnedValue Runtime::StrictNotEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -2309,21 +2437,21 @@ ReturnedValue Runtime::method_strictNotEqual(const Value &left, const Value &rig
     return Encode(r);
 }
 
-Bool Runtime::method_compareNotEqual(const Value &left, const Value &right)
+Bool Runtime::CompareNotEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    return !Runtime::method_compareEqual(left, right);
+    return !Runtime::CompareEqual::call(left, right);
 }
 
-Bool Runtime::method_compareStrictEqual(const Value &left, const Value &right)
+Bool Runtime::CompareStrictEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
     return RuntimeHelpers::strictEqual(left, right);
 }
 
-Bool Runtime::method_compareStrictNotEqual(const Value &left, const Value &right)
+Bool Runtime::CompareStrictNotEqual::call(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
diff --git a/src/qml/jsruntime/qv4runtime_p.h b/src/qml/jsruntime/qv4runtime_p.h
index 2be3ebf012..72af90d1dc 100644
--- a/src/qml/jsruntime/qv4runtime_p.h
+++ b/src/qml/jsruntime/qv4runtime_p.h
@@ -114,8 +114,6 @@ struct Q_QML_PRIVATE_EXPORT RuntimeHelpers {
     static Bool strictEqual(const Value &x, const Value &y);
 
     static ReturnedValue addHelper(ExecutionEngine *engine, const Value &left, const Value &right);
-
-    static ReturnedValue getTemplateObject(Function *function, int index);
 };
 
 
diff --git a/src/qml/jsruntime/qv4runtimeapi_p.h b/src/qml/jsruntime/qv4runtimeapi_p.h
index dc4dbb11b1..006cdeb765 100644
--- a/src/qml/jsruntime/qv4runtimeapi_p.h
+++ b/src/qml/jsruntime/qv4runtimeapi_p.h
@@ -57,184 +57,471 @@ QT_BEGIN_NAMESPACE
 namespace QV4 {
 
 typedef uint Bool;
-struct NoThrowEngine;
-namespace {
-template <typename T>
-struct ExceptionCheck {
-    enum { NeedsCheck = 1 };
-};
-// push_catch and pop context methods shouldn't check for exceptions
-template <>
-struct ExceptionCheck<void (*)(QV4::NoThrowEngine *)> {
-    enum { NeedsCheck = 0 };
-};
-template <typename A>
-struct ExceptionCheck<void (*)(A, QV4::NoThrowEngine)> {
-    enum { NeedsCheck = 0 };
-};
-template <>
-struct ExceptionCheck<QV4::ReturnedValue (*)(QV4::NoThrowEngine *)> {
-    enum { NeedsCheck = 0 };
-};
-template <typename A>
-struct ExceptionCheck<QV4::ReturnedValue (*)(QV4::NoThrowEngine *, A)> {
-    enum { NeedsCheck = 0 };
-};
-template <typename A, typename B>
-struct ExceptionCheck<QV4::ReturnedValue (*)(QV4::NoThrowEngine *, A, B)> {
-    enum { NeedsCheck = 0 };
-};
-template <typename A, typename B, typename C>
-struct ExceptionCheck<void (*)(QV4::NoThrowEngine *, A, B, C)> {
-    enum { NeedsCheck = 0 };
-};
-} // anonymous namespace
-
-#define FOR_EACH_RUNTIME_METHOD(F) \
-    /* call */ \
-    F(ReturnedValue, callGlobalLookup, (ExecutionEngine *engine, uint index, Value *argv, int argc)) \
-    F(ReturnedValue, callName, (ExecutionEngine *engine, int nameIndex, Value *argv, int argc)) \
-    F(ReturnedValue, callProperty, (ExecutionEngine *engine, Value *base, int nameIndex, Value *argv, int argc)) \
-    F(ReturnedValue, callPropertyLookup, (ExecutionEngine *engine, Value *base, uint index, Value *argv, int argc)) \
-    F(ReturnedValue, callElement, (ExecutionEngine *engine, Value *base, const Value &index, Value *argv, int argc)) \
-    F(ReturnedValue, callValue, (ExecutionEngine *engine, const Value &func, Value *argv, int argc)) \
-    F(ReturnedValue, callWithReceiver, (ExecutionEngine *engine, const Value &func, const Value *thisObject, Value *argv, int argc)) \
-    F(ReturnedValue, callPossiblyDirectEval, (ExecutionEngine *engine, Value *argv, int argc)) \
-    F(ReturnedValue, callWithSpread, (ExecutionEngine *engine, const Value &func, const Value &thisObject, Value *argv, int argc)) \
-    F(ReturnedValue, tailCall, (CppStackFrame *frame, ExecutionEngine *engine)) \
-    \
-    /* construct */ \
-    F(ReturnedValue, construct, (ExecutionEngine *engine, const Value &func, const Value &newTarget, Value *argv, int argc)) \
-    F(ReturnedValue, constructWithSpread, (ExecutionEngine *engine, const Value &func, const Value &newTarget, Value *argv, int argc)) \
-    \
-    /* load & store */ \
-    F(void, storeNameStrict, (ExecutionEngine *engine, int nameIndex, const Value &value)) \
-    F(void, storeNameSloppy, (ExecutionEngine *engine, int nameIndex, const Value &value)) \
-    F(void, storeProperty, (ExecutionEngine *engine, const Value &object, int nameIndex, const Value &value)) \
-    F(void, storeElement, (ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)) \
-    F(void, storeElement_traced, (ExecutionEngine *engine, const Value &object, const Value &index, const Value &value, quint8 *traceSlot)) \
-    F(ReturnedValue, loadProperty, (ExecutionEngine *engine, const Value &object, int nameIndex)) \
-    F(ReturnedValue, loadName, (ExecutionEngine *engine, int nameIndex)) \
-    F(ReturnedValue, loadElement, (ExecutionEngine *engine, const Value &object, const Value &index)) \
-    F(ReturnedValue, loadElement_traced, (ExecutionEngine *engine, const Value &object, const Value &index, quint8 *traceSlot)) \
-    F(ReturnedValue, loadSuperProperty, (ExecutionEngine *engine, const Value &property)) \
-    F(void, storeSuperProperty, (ExecutionEngine *engine, const Value &property, const Value &value)) \
-    F(ReturnedValue, loadSuperConstructor, (ExecutionEngine *engine, const Value &t)) \
-    \
-    /* typeof */  \
-    F(ReturnedValue, typeofValue, (ExecutionEngine *engine, const Value &val)) \
-    F(ReturnedValue, typeofName, (ExecutionEngine *engine, int nameIndex)) \
-    \
-    /* delete */ \
-    F(bool, deleteProperty, (ExecutionEngine *engine, const Value &base, const Value &index)) \
-    F(bool, deleteName, (ExecutionEngine *engine, int nameIndex)) \
-    \
-    /* exceptions & scopes */ \
-    F(void, throwException, (ExecutionEngine *engine, const Value &value)) \
-    F(ReturnedValue, createWithContext, (ExecutionEngine *, Value *jsStackFrame)) \
-    F(ReturnedValue, createCatchContext, (ExecutionContext *parent, int blockIndex, int exceptionVarNameIndex)) \
-    F(ReturnedValue, createBlockContext, (ExecutionContext *parent, int index)) \
-    F(ReturnedValue, createScriptContext, (ExecutionEngine *engine, int index)) \
-    F(ReturnedValue, cloneBlockContext, (ExecutionContext *previous)) \
-    F(ReturnedValue, popScriptContext, (ExecutionEngine *engine)) \
-    F(void, throwReferenceError, (ExecutionEngine *engine, int nameIndex)) \
-    \
-    /* closures */ \
-    F(ReturnedValue, closure, (ExecutionEngine *engine, int functionId)) \
-    \
-    /* function header */ \
-    F(void, declareVar, (ExecutionEngine *engine, bool deletable, int nameIndex)) \
-    F(ReturnedValue, createMappedArgumentsObject, (ExecutionEngine *engine)) \
-    F(ReturnedValue, createUnmappedArgumentsObject, (ExecutionEngine *engine)) \
-    F(ReturnedValue, createRestParameter, (ExecutionEngine *engine, int argIndex)) \
-    \
-    /* literals */ \
-    F(ReturnedValue, arrayLiteral, (ExecutionEngine *engine, Value *values, uint length)) \
-    F(ReturnedValue, objectLiteral, (ExecutionEngine *engine, int classId, const Value *args, int argc)) \
-    F(ReturnedValue, createClass, (ExecutionEngine *engine, int classIndex, const Value &heritage, const Value *computedNames)) \
-    \
-    /* for-in, for-of and array destructuring */ \
-    F(ReturnedValue, getIterator, (ExecutionEngine *engine, const Value &in, int iterator)) \
-    F(ReturnedValue, iteratorNext, (ExecutionEngine *engine, const Value &iterator, Value *value)) \
-    F(ReturnedValue, iteratorNextForYieldStar, (ExecutionEngine *engine, const Value &received, const Value &iterator, Value *object)) \
-    F(ReturnedValue, iteratorClose, (ExecutionEngine *engine, const Value &iterator, const Value &done)) \
-    F(ReturnedValue, destructureRestElement, (ExecutionEngine *engine, const Value &iterator)) \
-    \
-    /* unary operators */ \
-    F(ReturnedValue, uMinus, (const Value &value)) \
-    \
-    /* binary operators */ \
-    F(ReturnedValue, instanceof, (ExecutionEngine *engine, const Value &left, const Value &right)) \
-    F(ReturnedValue, in, (ExecutionEngine *engine, const Value &left, const Value &right)) \
-    F(ReturnedValue, add, (ExecutionEngine *engine, const Value &left, const Value &right)) \
-    F(ReturnedValue, sub, (const Value &left, const Value &right)) \
-    F(ReturnedValue, mul, (const Value &left, const Value &right)) \
-    F(ReturnedValue, div, (const Value &left, const Value &right)) \
-    F(ReturnedValue, mod, (const Value &left, const Value &right)) \
-    F(ReturnedValue, shl, (const Value &left, const Value &right)) \
-    F(ReturnedValue, shr, (const Value &left, const Value &right)) \
-    F(ReturnedValue, ushr, (const Value &left, const Value &right)) \
-    F(ReturnedValue, greaterThan, (const Value &left, const Value &right)) \
-    F(ReturnedValue, lessThan, (const Value &left, const Value &right)) \
-    F(ReturnedValue, greaterEqual, (const Value &left, const Value &right)) \
-    F(ReturnedValue, lessEqual, (const Value &left, const Value &right)) \
-    F(ReturnedValue, equal, (const Value &left, const Value &right)) \
-    F(ReturnedValue, notEqual, (const Value &left, const Value &right)) \
-    F(ReturnedValue, strictEqual, (const Value &left, const Value &right)) \
-    F(ReturnedValue, strictNotEqual, (const Value &left, const Value &right)) \
-    \
-    /* comparisons */ \
-    F(Bool, compareGreaterThan, (const Value &l, const Value &r)) \
-    F(Bool, compareLessThan, (const Value &l, const Value &r)) \
-    F(Bool, compareGreaterEqual, (const Value &l, const Value &r)) \
-    F(Bool, compareLessEqual, (const Value &l, const Value &r)) \
-    F(Bool, compareEqual, (const Value &left, const Value &right)) \
-    F(Bool, compareNotEqual, (const Value &left, const Value &right)) \
-    F(Bool, compareStrictEqual, (const Value &left, const Value &right)) \
-    F(Bool, compareStrictNotEqual, (const Value &left, const Value &right)) \
-    \
-    F(Bool, compareInstanceof, (ExecutionEngine *engine, const Value &left, const Value &right)) \
-    F(Bool, compareIn, (ExecutionEngine *engine, const Value &left, const Value &right)) \
-    \
-    F(ReturnedValue, regexpLiteral, (ExecutionEngine *engine, int id)) \
-    \
-    /* qml */ \
-    F(ReturnedValue, loadQmlContext, (NoThrowEngine *engine)) \
-    F(ReturnedValue, loadQmlImportedScripts, (NoThrowEngine *engine)) \
-    F(ReturnedValue, loadQmlScopeObjectProperty, (ExecutionEngine *engine, const Value &context, int propertyIndex, bool captureRequired)) \
-    F(ReturnedValue, loadQmlContextObjectProperty, (ExecutionEngine *engine, const Value &context, int propertyIndex, bool captureRequired)) \
-    F(ReturnedValue, loadQmlIdObject, (ExecutionEngine *engine, const Value &context, uint index)) \
-    F(ReturnedValue, callQmlScopeObjectProperty, (ExecutionEngine *engine, Value *base, int propertyIndex, Value *argv, int argc)) \
-    F(ReturnedValue, callQmlContextObjectProperty, (ExecutionEngine *engine, Value *base, int propertyIndex, Value *argv, int argc)) \
-    \
-    F(void, storeQmlScopeObjectProperty, (ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)) \
-    F(void, storeQmlContextObjectProperty, (ExecutionEngine *engine, const Value &context, int propertyIndex, const Value &value)) \
 
-struct Q_QML_PRIVATE_EXPORT Runtime {
-    Runtime();
 
+struct Q_QML_PRIVATE_EXPORT Runtime {
     typedef ReturnedValue (*UnaryOperation)(const Value &value);
     typedef ReturnedValue (*BinaryOperation)(const Value &left, const Value &right);
-    typedef ReturnedValue (*BinaryOperationContext)(ExecutionEngine *engine, const Value &left, const Value &right);
+    typedef ReturnedValue (*BinaryOperationContext)(ExecutionEngine *, const Value &left, const Value &right);
 
-#define DEFINE_RUNTIME_METHOD_ENUM(returnvalue, name, args) name,
-    enum RuntimeMethods {
-        FOR_EACH_RUNTIME_METHOD(DEFINE_RUNTIME_METHOD_ENUM)
-        RuntimeMethodCount,
-        InvalidRuntimeMethod = RuntimeMethodCount
+    enum class Throws { No, Yes };
+
+    template<Throws t>
+    struct Method {
+         static constexpr bool throws = t == Throws::Yes;
     };
-#undef DEFINE_RUNTIME_METHOD_ENUM
 
-    void *runtimeMethods[RuntimeMethodCount];
+    /* call */
+    struct Q_QML_PRIVATE_EXPORT CallGlobalLookup : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, uint, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallName : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, int, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallPropertyLookup : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, uint, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallElement : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallValue : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallWithReceiver : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallPossiblyDirectEval : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallWithSpread : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT TailCall : Method<Throws::Yes>
+    {
+        static ReturnedValue call(CppStackFrame *, ExecutionEngine *);
+    };
 
-    static uint runtimeMethodOffset(RuntimeMethods method) { return method*QT_POINTER_SIZE; }
+    /* construct Q_QML_PRIVATE_EXPORT */
+    struct Q_QML_PRIVATE_EXPORT Construct : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT ConstructWithSpread : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value[], int);
+    };
 
-#define RUNTIME_METHOD(returnvalue, name, args) \
-    typedef returnvalue (*Method_##name)args; \
-    enum { Method_##name##_NeedsExceptionCheck = ExceptionCheck<Method_##name>::NeedsCheck }; \
-    static returnvalue method_##name args;
-    FOR_EACH_RUNTIME_METHOD(RUNTIME_METHOD)
-#undef RUNTIME_METHOD
+    /* load & store */
+    struct Q_QML_PRIVATE_EXPORT StoreNameStrict : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, int, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreNameSloppy : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, int, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreProperty : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, int, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreElement : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreElement_traced : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, const Value &, const Value &, quint8 *);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadName : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadElement : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadElement_Traced : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, quint8 *);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadSuperProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreSuperProperty : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadSuperConstructor : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadGlobalLookup : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Function *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT GetLookup : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Function *, const Value &, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT SetLookupStrict : Method<Throws::Yes>
+    {
+        static void call(Function *, const Value &, int, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT SetLookupSloppy : Method<Throws::Yes>
+    {
+        static void call(Function *, const Value &, int, const Value &);
+    };
+
+    /* typeof */
+    struct Q_QML_PRIVATE_EXPORT TypeofValue : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT TypeofName : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *, int);
+    };
+
+    /* delete */
+    struct Q_QML_PRIVATE_EXPORT DeleteProperty_NoThrow : Method<Throws::No>
+    {
+        static Bool call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT DeleteProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Function *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT DeleteName_NoThrow : Method<Throws::No>
+    {
+        static Bool call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT DeleteName : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Function *, int);
+    };
+
+    /* exceptions & scopes */
+    struct Q_QML_PRIVATE_EXPORT ThrowException : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT PushCallContext : Method<Throws::No>
+    {
+        static void call(CppStackFrame *);
+    };
+    struct Q_QML_PRIVATE_EXPORT PushWithContext : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT PushCatchContext : Method<Throws::No>
+    {
+        static void call(ExecutionEngine *, int, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT PushBlockContext : Method<Throws::No>
+    {
+        static void call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CloneBlockContext : Method<Throws::No>
+    {
+        static void call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT PushScriptContext : Method<Throws::No>
+    {
+        static void call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT PopScriptContext : Method<Throws::No>
+    {
+        static void call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT ThrowReferenceError : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT ThrowOnNullOrUndefined : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &);
+    };
+
+    /* closures */
+    struct Q_QML_PRIVATE_EXPORT Closure : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *, int);
+    };
+
+    /* Function header */
+    struct Q_QML_PRIVATE_EXPORT ConvertThisToObject : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT DeclareVar : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, Bool, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CreateMappedArgumentsObject : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT CreateUnmappedArgumentsObject : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT CreateRestParameter : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, int);
+    };
+
+    /* literals */
+    struct Q_QML_PRIVATE_EXPORT ArrayLiteral : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, Value[], uint);
+    };
+    struct Q_QML_PRIVATE_EXPORT ObjectLiteral : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, int, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CreateClass : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, int, const Value &, Value[]);
+    };
+
+    /* for-in, for-of and array destructuring */
+    struct Q_QML_PRIVATE_EXPORT GetIterator : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT IteratorNext : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, Value *);
+    };
+    struct Q_QML_PRIVATE_EXPORT IteratorNextForYieldStar : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &, Value *);
+    };
+    struct Q_QML_PRIVATE_EXPORT IteratorClose : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT DestructureRestElement : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+
+    /* conversions */
+    struct Q_QML_PRIVATE_EXPORT ToObject : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT ToBoolean : Method<Throws::No>
+    {
+        static Bool call(const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT ToNumber : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &);
+    };
+    /* unary operators */
+    struct Q_QML_PRIVATE_EXPORT UMinus : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &);
+    };
+
+    /* binary operators */
+    struct Q_QML_PRIVATE_EXPORT Instanceof : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT In : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Add : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Sub : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Mul : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Div : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Mod : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Exp : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT BitAnd : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT BitOr : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT BitXor : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Shl : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Shr : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT UShr : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT GreaterThan : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT LessThan : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT GreaterEqual : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT LessEqual : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT Equal : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT NotEqual : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StrictEqual : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StrictNotEqual : Method<Throws::Yes>
+    {
+        static ReturnedValue call(const Value &, const Value &);
+    };
+
+    /* comparisons */
+    struct Q_QML_PRIVATE_EXPORT CompareGreaterThan : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareLessThan : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareGreaterEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareLessEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareNotEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareStrictEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareStrictNotEqual : Method<Throws::Yes>
+    {
+        static Bool call(const Value &, const Value &);
+    };
+
+    struct Q_QML_PRIVATE_EXPORT CompareInstanceof : Method<Throws::Yes>
+    {
+        static Bool call(ExecutionEngine *, const Value &, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT CompareIn : Method<Throws::Yes>
+    {
+        static Bool call(ExecutionEngine *, const Value &, const Value &);
+    };
+
+    struct Q_QML_PRIVATE_EXPORT RegexpLiteral : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *, int);
+    };
+    struct Q_QML_PRIVATE_EXPORT GetTemplateObject : Method<Throws::No>
+    {
+        static ReturnedValue call(Function *, int);
+    };
+
+    /* qml */
+    struct Q_QML_PRIVATE_EXPORT LoadQmlContext : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadQmlImportedScripts : Method<Throws::No>
+    {
+        static ReturnedValue call(ExecutionEngine *);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadQmlScopeObjectProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int, Bool);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadQmlContextObjectProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int, Bool);
+    };
+    struct Q_QML_PRIVATE_EXPORT LoadQmlIdObject : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, uint);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallQmlScopeObjectProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int, Value[], int);
+    };
+    struct Q_QML_PRIVATE_EXPORT CallQmlContextObjectProperty : Method<Throws::Yes>
+    {
+        static ReturnedValue call(ExecutionEngine *, const Value &, int, Value[], int);
+    };
+
+    struct Q_QML_PRIVATE_EXPORT StoreQmlScopeObjectProperty : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, int, const Value &);
+    };
+    struct Q_QML_PRIVATE_EXPORT StoreQmlContextObjectProperty : Method<Throws::Yes>
+    {
+        static void call(ExecutionEngine *, const Value &, int, const Value &);
+    };
 
     struct StackOffsets {
         static const int tailCall_function   = -1;
@@ -245,7 +532,6 @@ struct Q_QML_PRIVATE_EXPORT Runtime {
 };
 
 static_assert(std::is_standard_layout<Runtime>::value, "Runtime needs to be standard layout in order for us to be able to use offsetof");
-static_assert(offsetof(Runtime, runtimeMethods) == 0, "JIT expects this to be the first member");
 static_assert(sizeof(Runtime::BinaryOperation) == sizeof(void*), "JIT expects a function pointer to fit into a regular pointer, for cross-compilation offset translation");
 
 } // namespace QV4
diff --git a/src/qml/jsruntime/qv4setobject.cpp b/src/qml/jsruntime/qv4setobject.cpp
index 088ecbe30d..1664d1bd71 100644
--- a/src/qml/jsruntime/qv4setobject.cpp
+++ b/src/qml/jsruntime/qv4setobject.cpp
@@ -76,7 +76,7 @@ ReturnedValue WeakSetCtor::construct(const FunctionObject *f, const Value *argv,
             ScopedFunctionObject adder(scope, a->get(ScopedString(scope, scope.engine->newString(QString::fromLatin1("add")))));
             if (!adder)
                 return scope.engine->throwTypeError();
-            ScopedObject iter(scope, Runtime::method_getIterator(scope.engine, iterable, true));
+            ScopedObject iter(scope, Runtime::GetIterator::call(scope.engine, iterable, true));
             CHECK_EXCEPTION();
             if (!iter)
                 return a.asReturnedValue();
@@ -84,7 +84,7 @@ ReturnedValue WeakSetCtor::construct(const FunctionObject *f, const Value *argv,
             Value *nextValue = scope.alloc(1);
             ScopedValue done(scope);
             forever {
-                done = Runtime::method_iteratorNext(scope.engine, iter, nextValue);
+                done = Runtime::IteratorNext::call(scope.engine, iter, nextValue);
                 CHECK_EXCEPTION();
                 if (done->toBoolean())
                     return a.asReturnedValue();
@@ -92,7 +92,7 @@ ReturnedValue WeakSetCtor::construct(const FunctionObject *f, const Value *argv,
                 adder->call(a, nextValue, 1);
                 if (scope.engine->hasException) {
                     ScopedValue falsey(scope, Encode(false));
-                    return Runtime::method_iteratorClose(scope.engine, iter, falsey);
+                    return Runtime::IteratorClose::call(scope.engine, iter, falsey);
                 }
             }
         }
diff --git a/src/qml/jsruntime/qv4typedarray.cpp b/src/qml/jsruntime/qv4typedarray.cpp
index faf7934c06..d83f021450 100644
--- a/src/qml/jsruntime/qv4typedarray.cpp
+++ b/src/qml/jsruntime/qv4typedarray.cpp
@@ -1595,7 +1595,7 @@ ReturnedValue IntrinsicTypedArrayPrototype::method_toLocaleString(const Function
             R += separator;
 
         v = instance->get(k);
-        v = Runtime::method_callElement(scope.engine, v, *scope.engine->id_toLocaleString(), nullptr, 0);
+        v = Runtime::CallElement::call(scope.engine, v, *scope.engine->id_toLocaleString(), nullptr, 0);
         s = v->toString(scope.engine);
         if (scope.hasException())
             return Encode::undefined();
diff --git a/src/qml/jsruntime/qv4vme_moth.cpp b/src/qml/jsruntime/qv4vme_moth.cpp
index d69a0fe34e..c16bd7aae1 100644
--- a/src/qml/jsruntime/qv4vme_moth.cpp
+++ b/src/qml/jsruntime/qv4vme_moth.cpp
@@ -607,16 +607,16 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_END_INSTR(LoadRuntimeString)
 
     MOTH_BEGIN_INSTR(MoveRegExp)
-        STACK_VALUE(destReg) = Runtime::method_regexpLiteral(engine, regExpId);
+        STACK_VALUE(destReg) = Runtime::RegexpLiteral::call(engine, regExpId);
     MOTH_END_INSTR(MoveRegExp)
 
     MOTH_BEGIN_INSTR(LoadClosure)
-        acc = Runtime::method_closure(engine, value);
+        acc = Runtime::Closure::call(engine, value);
     MOTH_END_INSTR(LoadClosure)
 
     MOTH_BEGIN_INSTR(LoadName)
         STORE_IP();
-        acc = Runtime::method_loadName(engine, name);
+        acc = Runtime::LoadName::call(engine, name);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(LoadName)
@@ -632,14 +632,14 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(StoreNameStrict)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_storeNameStrict(engine, name, accumulator);
+        Runtime::StoreNameStrict::call(engine, name, accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreNameStrict)
 
     MOTH_BEGIN_INSTR(StoreNameSloppy)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_storeNameSloppy(engine, name, accumulator);
+        Runtime::StoreNameSloppy::call(engine, name, accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreNameSloppy)
 
@@ -647,11 +647,11 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
         STORE_IP();
         STORE_ACC();
 #if QT_CONFIG(qml_tracing)
-        acc = Runtime::method_loadElement_traced(engine, STACK_VALUE(base), accumulator, function->traceInfo(traceSlot));
+        acc = Runtime::LoadElement_Traced::call(engine, STACK_VALUE(base), accumulator, function->traceInfo(traceSlot));
         traceValue(acc, function, traceSlot);
 #else
         Q_UNUSED(traceSlot);
-        acc = Runtime::method_loadElement(engine, STACK_VALUE(base), accumulator);
+        acc = Runtime::LoadElement::call(engine, STACK_VALUE(base), accumulator);
 #endif
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadElement)
@@ -660,10 +660,10 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
         STORE_IP();
         STORE_ACC();
 #if QT_CONFIG(qml_tracing)
-        Runtime::method_storeElement_traced(engine, STACK_VALUE(base), STACK_VALUE(index), accumulator, function->traceInfo(traceSlot));
+        Runtime::StoreElement_traced::call(engine, STACK_VALUE(base), STACK_VALUE(index), accumulator, function->traceInfo(traceSlot));
 #else
         Q_UNUSED(traceSlot);
-        Runtime::method_storeElement(engine, STACK_VALUE(base), STACK_VALUE(index), accumulator);
+        Runtime::StoreElement::call(engine, STACK_VALUE(base), STACK_VALUE(index), accumulator);
 #endif
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreElement)
@@ -671,7 +671,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(LoadProperty)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_loadProperty(engine, accumulator, name);
+        acc = Runtime::LoadProperty::call(engine, accumulator, name);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(LoadProperty)
@@ -688,7 +688,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(StoreProperty)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_storeProperty(engine, STACK_VALUE(base), name, accumulator);
+        Runtime::StoreProperty::call(engine, STACK_VALUE(base), name, accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreProperty)
 
@@ -704,45 +704,45 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(LoadSuperProperty)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_loadSuperProperty(engine, STACK_VALUE(property));
+        acc = Runtime::LoadSuperProperty::call(engine, STACK_VALUE(property));
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadSuperProperty)
 
     MOTH_BEGIN_INSTR(StoreSuperProperty)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_storeSuperProperty(engine, STACK_VALUE(property), accumulator);
+        Runtime::StoreSuperProperty::call(engine, STACK_VALUE(property), accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreSuperProperty)
 
     MOTH_BEGIN_INSTR(StoreScopeObjectProperty)
         STORE_ACC();
-        Runtime::method_storeQmlScopeObjectProperty(engine, STACK_VALUE(base), propertyIndex, accumulator);
+        Runtime::StoreQmlScopeObjectProperty::call(engine, STACK_VALUE(base), propertyIndex, accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreScopeObjectProperty)
 
     MOTH_BEGIN_INSTR(LoadScopeObjectProperty)
         STORE_IP();
-        acc = Runtime::method_loadQmlScopeObjectProperty(engine, STACK_VALUE(base), propertyIndex, captureRequired);
+        acc = Runtime::LoadQmlScopeObjectProperty::call(engine, STACK_VALUE(base), propertyIndex, captureRequired);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadScopeObjectProperty)
 
     MOTH_BEGIN_INSTR(StoreContextObjectProperty)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_storeQmlContextObjectProperty(engine, STACK_VALUE(base), propertyIndex, accumulator);
+        Runtime::StoreQmlContextObjectProperty::call(engine, STACK_VALUE(base), propertyIndex, accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(StoreContextObjectProperty)
 
     MOTH_BEGIN_INSTR(LoadContextObjectProperty)
         STORE_IP();
-        acc = Runtime::method_loadQmlContextObjectProperty(engine, STACK_VALUE(base), propertyIndex, captureRequired);
+        acc = Runtime::LoadQmlContextObjectProperty::call(engine, STACK_VALUE(base), propertyIndex, captureRequired);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadContextObjectProperty)
 
     MOTH_BEGIN_INSTR(LoadIdObject)
         STORE_IP();
-        acc = Runtime::method_loadQmlIdObject(engine, STACK_VALUE(base), index);
+        acc = Runtime::LoadQmlIdObject::call(engine, STACK_VALUE(base), index);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadIdObject)
 
@@ -773,7 +773,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
 
     MOTH_BEGIN_INSTR(IteratorNextForYieldStar)
         STORE_ACC();
-        acc = Runtime::method_iteratorNextForYieldStar(engine, accumulator, STACK_VALUE(iterator), &STACK_VALUE(object));
+        acc = Runtime::IteratorNextForYieldStar::call(engine, accumulator, STACK_VALUE(iterator), &STACK_VALUE(object));
         CHECK_EXCEPTION;
     MOTH_END_INSTR(IteratorNextForYieldStar)
 
@@ -804,7 +804,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
 
     MOTH_BEGIN_INSTR(CallProperty)
         STORE_IP();
-        acc = Runtime::method_callProperty(engine, stack + base, name, stack + argv, argc);
+        acc = Runtime::CallProperty::call(engine, stack[base], name, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallProperty)
@@ -827,49 +827,49 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
 
     MOTH_BEGIN_INSTR(CallElement)
         STORE_IP();
-        acc = Runtime::method_callElement(engine, stack + base, STACK_VALUE(index), stack + argv, argc);
+        acc = Runtime::CallElement::call(engine, stack[base], STACK_VALUE(index), stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallElement)
 
     MOTH_BEGIN_INSTR(CallName)
         STORE_IP();
-        acc = Runtime::method_callName(engine, name, stack + argv, argc);
+        acc = Runtime::CallName::call(engine, name, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallName)
 
     MOTH_BEGIN_INSTR(CallPossiblyDirectEval)
         STORE_IP();
-        acc = Runtime::method_callPossiblyDirectEval(engine, stack + argv, argc);
+        acc = Runtime::CallPossiblyDirectEval::call(engine, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallPossiblyDirectEval)
 
     MOTH_BEGIN_INSTR(CallGlobalLookup)
         STORE_IP();
-        acc = Runtime::method_callGlobalLookup(engine, index, stack + argv, argc);
+        acc = Runtime::CallGlobalLookup::call(engine, index, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallGlobalLookup)
 
     MOTH_BEGIN_INSTR(CallScopeObjectProperty)
         STORE_IP();
-        acc = Runtime::method_callQmlScopeObjectProperty(engine, stack + base, name, stack + argv, argc);
+        acc = Runtime::CallQmlScopeObjectProperty::call(engine, stack[base], name, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallScopeObjectProperty)
 
     MOTH_BEGIN_INSTR(CallContextObjectProperty)
         STORE_IP();
-        acc = Runtime::method_callQmlContextObjectProperty(engine, stack + base, name, stack + argv, argc);
+        acc = Runtime::CallQmlContextObjectProperty::call(engine, stack[base], name, stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallContextObjectProperty)
 
     MOTH_BEGIN_INSTR(CallWithSpread)
         STORE_IP();
-        acc = Runtime::method_callWithSpread(engine, STACK_VALUE(func), STACK_VALUE(thisObject), stack + argv, argc);
+        acc = Runtime::CallWithSpread::call(engine, STACK_VALUE(func), STACK_VALUE(thisObject), stack + argv, argc);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(CallWithSpread)
@@ -880,19 +880,19 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
         *engine->jsAlloca(1) = Primitive::fromInt32(argv);
         *engine->jsAlloca(1) = STACK_VALUE(thisObject);
         *engine->jsAlloca(1) = STACK_VALUE(func);
-        return Runtime::method_tailCall(frame, engine);
+        return Runtime::TailCall::call(frame, engine);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(TailCall)
 
     MOTH_BEGIN_INSTR(Construct)
         STORE_IP();
-        acc = Runtime::method_construct(engine, STACK_VALUE(func), ACC, stack + argv, argc);
+        acc = Runtime::Construct::call(engine, STACK_VALUE(func), ACC, stack + argv, argc);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(Construct)
 
     MOTH_BEGIN_INSTR(ConstructWithSpread)
         STORE_IP();
-        acc = Runtime::method_constructWithSpread(engine, STACK_VALUE(func), ACC, stack + argv, argc);
+        acc = Runtime::ConstructWithSpread::call(engine, STACK_VALUE(func), ACC, stack + argv, argc);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(ConstructWithSpread)
 
@@ -920,7 +920,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
         if (ACC.isEmpty()) {
             STORE_IP();
             STORE_ACC();
-            Runtime::method_throwReferenceError(engine, name);
+            Runtime::ThrowReferenceError::call(engine, name);
             goto handleUnwind;
         }
     MOTH_END_INSTR(DeadTemporalZoneCheck)
@@ -928,7 +928,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(ThrowException)
         STORE_IP();
         STORE_ACC();
-        Runtime::method_throwException(engine, accumulator);
+        Runtime::ThrowException::call(engine, accumulator);
         goto handleUnwind;
     MOTH_END_INSTR(ThrowException)
 
@@ -946,40 +946,36 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_END_INSTR(SetException)
 
     MOTH_BEGIN_INSTR(PushCatchContext)
-        ExecutionContext *c = static_cast<ExecutionContext *>(stack + CallData::Context);
-        STACK_VALUE(CallData::Context) = Runtime::method_createCatchContext(c, index, name);
+        Runtime::PushCatchContext::call(engine, index, name);
     MOTH_END_INSTR(PushCatchContext)
 
     MOTH_BEGIN_INSTR(CreateCallContext)
-        stack[CallData::Context] = ExecutionContext::newCallContext(frame);
+        Runtime::PushCallContext::call(frame);
     MOTH_END_INSTR(CreateCallContext)
 
     MOTH_BEGIN_INSTR(PushWithContext)
         STORE_IP();
         STORE_ACC();
-        auto ctx = Runtime::method_createWithContext(engine, stack);
+        acc = Runtime::PushWithContext::call(engine, stack[CallData::Accumulator]);
         CHECK_EXCEPTION;
-        STACK_VALUE(CallData::Context) = ctx;
     MOTH_END_INSTR(PushWithContext)
 
     MOTH_BEGIN_INSTR(PushBlockContext)
         STORE_ACC();
-        ExecutionContext *c = static_cast<ExecutionContext *>(stack + CallData::Context);
-        STACK_VALUE(CallData::Context) = Runtime::method_createBlockContext(c, index);
+        Runtime::PushBlockContext::call(engine, index);
     MOTH_END_INSTR(PushBlockContext)
 
     MOTH_BEGIN_INSTR(CloneBlockContext)
         STORE_ACC();
-        ExecutionContext *c = static_cast<ExecutionContext *>(stack + CallData::Context);
-        STACK_VALUE(CallData::Context) = Runtime::method_cloneBlockContext(c);
+        Runtime::CloneBlockContext::call(engine);
     MOTH_END_INSTR(CloneBlockContext)
 
     MOTH_BEGIN_INSTR(PushScriptContext)
-        STACK_VALUE(CallData::Context) = Runtime::method_createScriptContext(engine, index);
+        Runtime::PushScriptContext::call(engine, index);
     MOTH_END_INSTR(PushScriptContext)
 
     MOTH_BEGIN_INSTR(PopScriptContext)
-        STACK_VALUE(CallData::Context) = Runtime::method_popScriptContext(engine);
+        Runtime::PopScriptContext::call(engine);
     MOTH_END_INSTR(PopScriptContext)
 
     MOTH_BEGIN_INSTR(PopContext)
@@ -990,14 +986,14 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(GetIterator)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_getIterator(engine, accumulator, iterator);
+        acc = Runtime::GetIterator::call(engine, accumulator, iterator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(GetIterator)
 
     MOTH_BEGIN_INSTR(IteratorNext)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_iteratorNext(engine, accumulator, &STACK_VALUE(value));
+        acc = Runtime::IteratorNext::call(engine, accumulator, &STACK_VALUE(value));
         STACK_VALUE(done) = acc;
         CHECK_EXCEPTION;
     MOTH_END_INSTR(IteratorNext)
@@ -1005,97 +1001,73 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(IteratorClose)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_iteratorClose(engine, accumulator, STACK_VALUE(done));
+        acc = Runtime::IteratorClose::call(engine, accumulator, STACK_VALUE(done));
         CHECK_EXCEPTION;
     MOTH_END_INSTR(IteratorClose)
 
     MOTH_BEGIN_INSTR(DestructureRestElement)
         STORE_IP();
         STORE_ACC();
-        acc = Runtime::method_destructureRestElement(engine, ACC);
+        acc = Runtime::DestructureRestElement::call(engine, ACC);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(DestructureRestElement)
 
     MOTH_BEGIN_INSTR(DeleteProperty)
-        if (!Runtime::method_deleteProperty(engine, STACK_VALUE(base), STACK_VALUE(index))) {
-            if (function->isStrict()) {
-                STORE_IP();
-                engine->throwTypeError();
-                goto handleUnwind;
-            }
-            acc = Encode(false);
-        } else {
-            acc = Encode(true);
-        }
+        acc = Runtime::DeleteProperty::call(engine, function, STACK_VALUE(base), STACK_VALUE(index));
+        CHECK_EXCEPTION;
     MOTH_END_INSTR(DeleteProperty)
 
     MOTH_BEGIN_INSTR(DeleteName)
-        if (!Runtime::method_deleteName(engine, name)) {
-            if (function->isStrict()) {
-                STORE_IP();
-                QString n = function->compilationUnit->runtimeStrings[name]->toQString();
-                engine->throwSyntaxError(QStringLiteral("Can't delete property %1").arg(n));
-                goto handleUnwind;
-            }
-            acc = Encode(false);
-        } else {
-            acc = Encode(true);
-        }
+        acc = Runtime::DeleteName::call(engine, function, name);
+        CHECK_EXCEPTION;
     MOTH_END_INSTR(DeleteName)
 
     MOTH_BEGIN_INSTR(TypeofName)
-        acc = Runtime::method_typeofName(engine, name);
+        acc = Runtime::TypeofName::call(engine, name);
     MOTH_END_INSTR(TypeofName)
 
     MOTH_BEGIN_INSTR(TypeofValue)
         STORE_ACC();
-        acc = Runtime::method_typeofValue(engine, accumulator);
+        acc = Runtime::TypeofValue::call(engine, accumulator);
     MOTH_END_INSTR(TypeofValue)
 
     MOTH_BEGIN_INSTR(DeclareVar)
-        Runtime::method_declareVar(engine, isDeletable, varName);
+        Runtime::DeclareVar::call(engine, isDeletable, varName);
     MOTH_END_INSTR(DeclareVar)
 
     MOTH_BEGIN_INSTR(DefineArray)
         QV4::Value *arguments = stack + args;
-        acc = Runtime::method_arrayLiteral(engine, arguments, argc);
+        acc = Runtime::ArrayLiteral::call(engine, arguments, argc);
     MOTH_END_INSTR(DefineArray)
 
     MOTH_BEGIN_INSTR(DefineObjectLiteral)
         QV4::Value *arguments = stack + args;
-        acc = Runtime::method_objectLiteral(engine, internalClassId, arguments, argc);
+        acc = Runtime::ObjectLiteral::call(engine, internalClassId, arguments, argc);
     MOTH_END_INSTR(DefineObjectLiteral)
 
     MOTH_BEGIN_INSTR(CreateClass)
-        acc = Runtime::method_createClass(engine, classIndex, STACK_VALUE(heritage), stack + computedNames);
+        acc = Runtime::CreateClass::call(engine, classIndex, STACK_VALUE(heritage), stack + computedNames);
     MOTH_END_INSTR(CreateClass)
 
     MOTH_BEGIN_INSTR(CreateMappedArgumentsObject)
-        acc = Runtime::method_createMappedArgumentsObject(engine);
+        acc = Runtime::CreateMappedArgumentsObject::call(engine);
     MOTH_END_INSTR(CreateMappedArgumentsObject)
 
     MOTH_BEGIN_INSTR(CreateUnmappedArgumentsObject)
-        acc = Runtime::method_createUnmappedArgumentsObject(engine);
+        acc = Runtime::CreateUnmappedArgumentsObject::call(engine);
     MOTH_END_INSTR(CreateUnmappedArgumentsObject)
 
     MOTH_BEGIN_INSTR(CreateRestParameter)
-        acc = Runtime::method_createRestParameter(engine, argIndex);
+        acc = Runtime::CreateRestParameter::call(engine, argIndex);
     MOTH_END_INSTR(CreateRestParameter)
 
     MOTH_BEGIN_INSTR(ConvertThisToObject)
-        Value *t = &stack[CallData::This];
-        if (!t->isObject()) {
-            if (t->isNullOrUndefined()) {
-                *t = engine->globalObject->asReturnedValue();
-            } else {
-                *t = t->toObject(engine)->asReturnedValue();
-                CHECK_EXCEPTION;
-            }
-        }
+        stack[CallData::This] = Runtime::ConvertThisToObject::call(engine, stack[CallData::This]);
+        CHECK_EXCEPTION;
     MOTH_END_INSTR(ConvertThisToObject)
 
     MOTH_BEGIN_INSTR(LoadSuperConstructor)
-        acc = Runtime::method_loadSuperConstructor(engine, stack[CallData::Function]);
+        acc = Runtime::LoadSuperConstructor::call(engine, stack[CallData::Function]);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(LoadSuperConstructor)
 
@@ -1176,7 +1148,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(left.int_32() == ACC.int_32());
         } else {
             STORE_ACC();
-            acc = Encode(bool(Runtime::method_compareEqual(left, accumulator)));
+            acc = Encode(bool(Runtime::CompareEqual::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpEq)
@@ -1187,7 +1159,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(bool(left.int_32() != ACC.int_32()));
         } else {
             STORE_ACC();
-            acc = Encode(bool(!Runtime::method_compareEqual(left, accumulator)));
+            acc = Encode(bool(!Runtime::CompareEqual::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpNe)
@@ -1200,7 +1172,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(left.asDouble() > ACC.asDouble());
         } else {
             STORE_ACC();
-            acc = Encode(bool(Runtime::method_compareGreaterThan(left, accumulator)));
+            acc = Encode(bool(Runtime::CompareGreaterThan::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpGt)
@@ -1213,7 +1185,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(left.asDouble() >= ACC.asDouble());
         } else {
             STORE_ACC();
-            acc = Encode(bool(Runtime::method_compareGreaterEqual(left, accumulator)));
+            acc = Encode(bool(Runtime::CompareGreaterEqual::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpGe)
@@ -1226,7 +1198,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(left.asDouble() < ACC.asDouble());
         } else {
             STORE_ACC();
-            acc = Encode(bool(Runtime::method_compareLessThan(left, accumulator)));
+            acc = Encode(bool(Runtime::CompareLessThan::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpLt)
@@ -1239,7 +1211,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(left.asDouble() <= ACC.asDouble());
         } else {
             STORE_ACC();
-            acc = Encode(bool(Runtime::method_compareLessEqual(left, accumulator)));
+            acc = Encode(bool(Runtime::CompareLessEqual::call(left, accumulator)));
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpLe)
@@ -1249,7 +1221,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             acc = Encode(true);
         } else {
             STORE_ACC();
-            acc = Encode(bool(RuntimeHelpers::strictEqual(STACK_VALUE(lhs), accumulator)));
+            acc = Runtime::StrictEqual::call(STACK_VALUE(lhs), accumulator);
             CHECK_EXCEPTION;
         }
     MOTH_END_INSTR(CmpStrictEqual)
@@ -1257,7 +1229,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_BEGIN_INSTR(CmpStrictNotEqual)
         if (STACK_VALUE(lhs).rawValue() != ACC.rawValue() || ACC.isNaN()) {
             STORE_ACC();
-            acc = Encode(!RuntimeHelpers::strictEqual(STACK_VALUE(lhs), accumulator));
+            acc = Runtime::StrictNotEqual::call(STACK_VALUE(lhs), accumulator);
             CHECK_EXCEPTION;
         } else {
             acc = Encode(false);
@@ -1266,13 +1238,13 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
 
     MOTH_BEGIN_INSTR(CmpIn)
         STORE_ACC();
-        acc = Runtime::method_in(engine, STACK_VALUE(lhs), accumulator);
+        acc = Runtime::In::call(engine, STACK_VALUE(lhs), accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(CmpIn)
 
     MOTH_BEGIN_INSTR(CmpInstanceOf)
         STORE_ACC();
-        acc = Runtime::method_instanceof(engine, STACK_VALUE(lhs), ACC);
+        acc = Runtime::Instanceof::call(engine, STACK_VALUE(lhs), ACC);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(CmpInstanceOf)
 
@@ -1350,7 +1322,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             traceDoubleValue(function, traceSlot);
         } else {
             STORE_ACC();
-            acc = Runtime::method_add(engine, left, accumulator);
+            acc = Runtime::Add::call(engine, left, accumulator);
             CHECK_EXCEPTION;
             traceOtherValue(function, traceSlot);
         }
@@ -1365,7 +1337,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             traceDoubleValue(function, traceSlot);
         } else {
             STORE_ACC();
-            acc = Runtime::method_sub(left, accumulator);
+            acc = Runtime::Sub::call(left, accumulator);
             CHECK_EXCEPTION;
             traceOtherValue(function, traceSlot);
         }
@@ -1390,7 +1362,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
             traceDoubleValue(function, traceSlot);
         } else {
             STORE_ACC();
-            acc = Runtime::method_mul(left, accumulator);
+            acc = Runtime::Mul::call(left, accumulator);
             CHECK_EXCEPTION;
             traceOtherValue(function, traceSlot);
         }
@@ -1398,13 +1370,13 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
 
     MOTH_BEGIN_INSTR(Div)
         STORE_ACC();
-        acc = Runtime::method_div(STACK_VALUE(lhs), accumulator);
+        acc = Runtime::Div::call(STACK_VALUE(lhs), accumulator);
         CHECK_EXCEPTION;
     MOTH_END_INSTR(Div)
 
     MOTH_BEGIN_INSTR(Mod)
         STORE_ACC();
-        acc = Runtime::method_mod(STACK_VALUE(lhs), accumulator);
+        acc = Runtime::Mod::call(STACK_VALUE(lhs), accumulator);
         CHECK_EXCEPTION;
         traceValue(acc, function, traceSlot);
     MOTH_END_INSTR(Mod)
@@ -1493,7 +1465,7 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_END_INSTR(ThrowOnNullOrUndefined)
 
     MOTH_BEGIN_INSTR(GetTemplateObject)
-        acc = RuntimeHelpers::getTemplateObject(function, index);
+        acc = Runtime::GetTemplateObject::call(function, index);
     MOTH_END_INSTR(GetTemplateObject)
 
     MOTH_BEGIN_INSTR(Debug)
@@ -1504,11 +1476,11 @@ QV4::ReturnedValue VME::interpret(CppStackFrame *frame, ExecutionEngine *engine,
     MOTH_END_INSTR(Debug)
 
     MOTH_BEGIN_INSTR(LoadQmlContext)
-        STACK_VALUE(result) = Runtime::method_loadQmlContext(static_cast<QV4::NoThrowEngine*>(engine));
+        STACK_VALUE(result) = Runtime::LoadQmlContext::call(engine);
     MOTH_END_INSTR(LoadQmlContext)
 
     MOTH_BEGIN_INSTR(LoadQmlImportedScripts)
-        STACK_VALUE(result) = Runtime::method_loadQmlImportedScripts(static_cast<QV4::NoThrowEngine*>(engine));
+        STACK_VALUE(result) = Runtime::LoadQmlImportedScripts::call(engine);
     MOTH_END_INSTR(LoadQmlImportedScripts)
 
     handleUnwind: