Separate SimpleCallData and CallData

SimpleCallData doesn't need any loca variables, so
move it into a separate CallData Heap object. This
also allows getting rid of the manual markObjects()
implementation for CallContext.

Change-Id: I9014eb2f815d3e2fe63a951a9d126c38e8aaa0a3
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

11 files changed, 106 insertions, 116 deletions

diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
index a4bad5618b..225a1fa27d 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
@@ -55,11 +55,11 @@
 
 QT_BEGIN_NAMESPACE
 
-QV4::CallContext *QV4DataCollector::findContext(int frame)
+QV4::SimpleCallContext *QV4DataCollector::findContext(int frame)
 {
     QV4::ExecutionContext *ctx = engine()->currentContext;
     while (ctx) {
-        QV4::CallContext *cCtxt = ctx->asCallContext();
+        QV4::SimpleCallContext *cCtxt = ctx->asSimpleCallContext();
         if (cCtxt && cCtxt->d()->v4Function) {
             if (frame < 1)
                 return cCtxt;
@@ -71,7 +71,7 @@ QV4::CallContext *QV4DataCollector::findContext(int frame)
     return 0;
 }
 
-QV4::Heap::CallContext *QV4DataCollector::findScope(QV4::ExecutionContext *ctxt, int scope)
+QV4::Heap::SimpleCallContext *QV4DataCollector::findScope(QV4::ExecutionContext *ctxt, int scope)
 {
     if (!ctxt)
         return 0;
@@ -81,7 +81,7 @@ QV4::Heap::CallContext *QV4DataCollector::findScope(QV4::ExecutionContext *ctxt,
     for (; scope > 0 && ctx; --scope)
         ctx = ctx->d()->outer;
 
-    return (ctx && ctx->d()) ? ctx->asCallContext()->d() : 0;
+    return (ctx && ctx->d()) ? ctx->asSimpleCallContext()->d() : 0;
 }
 
 QVector<QV4::Heap::ExecutionContext::ContextType> QV4DataCollector::getScopeTypes(int frame)
@@ -89,7 +89,7 @@ QVector<QV4::Heap::ExecutionContext::ContextType> QV4DataCollector::getScopeType
     QVector<QV4::Heap::ExecutionContext::ContextType> types;
 
     QV4::Scope scope(engine());
-    QV4::CallContext *sctxt = findContext(frame);
+    QV4::SimpleCallContext *sctxt = findContext(frame);
     if (!sctxt || sctxt->d()->type < QV4::Heap::ExecutionContext::Type_QmlContext)
         return types;
 
@@ -310,7 +310,7 @@ QJsonObject QV4DataCollector::buildFrame(const QV4::StackFrame &stackFrame, int
     QV4::Scope scope(engine());
     QV4::ScopedContext ctxt(scope, findContext(frameNr));
     while (ctxt) {
-        if (QV4::CallContext *cCtxt = ctxt->asCallContext()) {
+        if (QV4::SimpleCallContext *cCtxt = ctxt->asSimpleCallContext()) {
             if (cCtxt->d()->activation)
                 break;
         }
@@ -318,7 +318,7 @@ QJsonObject QV4DataCollector::buildFrame(const QV4::StackFrame &stackFrame, int
     }
 
     if (ctxt) {
-        QV4::ScopedValue o(scope, ctxt->asCallContext()->d()->activation);
+        QV4::ScopedValue o(scope, ctxt->asSimpleCallContext()->d()->activation);
         frame[QLatin1String("receiver")] = toRef(collect(o));
     }
 
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
index fd6356f22e..09a0d683ba 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
@@ -58,11 +58,11 @@ public:
     typedef uint Ref;
     typedef QVector<uint> Refs;
 
-    static QV4::Heap::CallContext *findScope(QV4::ExecutionContext *ctxt, int scope);
+    static QV4::Heap::SimpleCallContext *findScope(QV4::ExecutionContext *ctxt, int scope);
     static int encodeScopeType(QV4::Heap::ExecutionContext::ContextType scopeType);
 
     QVector<QV4::Heap::ExecutionContext::ContextType> getScopeTypes(int frame);
-    QV4::CallContext *findContext(int frame);
+    QV4::SimpleCallContext *findContext(int frame);
 
     QV4DataCollector(QV4::ExecutionEngine *engine);
 
diff --git a/src/plugins/qmltooling/qmldbg_nativedebugger/qqmlnativedebugservice.cpp b/src/plugins/qmltooling/qmldbg_nativedebugger/qqmlnativedebugservice.cpp
index 7f842419e7..6cb1ab4051 100644
--- a/src/plugins/qmltooling/qmldbg_nativedebugger/qqmlnativedebugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_nativedebugger/qqmlnativedebugservice.cpp
@@ -481,17 +481,20 @@ void NativeDebugger::handleVariables(QJsonObject *response, const QJsonObject &a
     QJsonArray output;
     QV4::Scope scope(engine);
 
-    if (QV4::CallContext *callContext = executionContext->asCallContext()) {
+    if (QV4::SimpleCallContext *callContext = executionContext->asSimpleCallContext()) {
         QV4::Value thisObject = callContext->thisObject();
         collector.collect(&output, QString(), QStringLiteral("this"), thisObject);
         QV4::Identifier *const *variables = callContext->variables();
         QV4::Identifier *const *formals = callContext->formals();
-        for (unsigned i = 0, ei = callContext->variableCount(); i != ei; ++i) {
-            QString qName;
-            if (QV4::Identifier *name = variables[i])
-                qName = name->string;
-            QV4::Value val = callContext->d()->locals[i];
-            collector.collect(&output, QString(), qName, val);
+        if (callContext->d()->type == QV4::Heap::ExecutionContext::Type_CallContext) {
+            QV4::CallContext *ctx = static_cast<QV4::CallContext *>(callContext);
+            for (unsigned i = 0, ei = ctx->variableCount(); i != ei; ++i) {
+                QString qName;
+                if (QV4::Identifier *name = variables[i])
+                    qName = name->string;
+                QV4::Value val = ctx->d()->locals[i];
+                collector.collect(&output, QString(), qName, val);
+            }
         }
         for (unsigned i = 0, ei = callContext->formalCount(); i != ei; ++i) {
             QString qName;
diff --git a/src/qml/jit/qv4assembler.cpp b/src/qml/jit/qv4assembler.cpp
index 0b3d0bd0cc..83baef8453 100644
--- a/src/qml/jit/qv4assembler.cpp
+++ b/src/qml/jit/qv4assembler.cpp
@@ -286,7 +286,7 @@ typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>:
     } break;
     case IR::ArgLocal::Local:
     case IR::ArgLocal::ScopedLocal: {
-        offset = qOffsetOf(CallContext::Data, locals) + al->index * sizeof(Value);
+        offset = qOffsetOf(CallContext::Data, locals.v) + al->index * sizeof(Value);
     } break;
     default:
         Q_UNREACHABLE();
diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp
index 569523595c..ec11422c15 100644
--- a/src/qml/jsruntime/qv4context.cpp
+++ b/src/qml/jsruntime/qv4context.cpp
@@ -54,20 +54,19 @@
 using namespace QV4;
 
 DEFINE_MANAGED_VTABLE(ExecutionContext);
+DEFINE_MANAGED_VTABLE(SimpleCallContext);
 DEFINE_MANAGED_VTABLE(CallContext);
 DEFINE_MANAGED_VTABLE(WithContext);
 DEFINE_MANAGED_VTABLE(CatchContext);
 DEFINE_MANAGED_VTABLE(GlobalContext);
 
-/* Function *f, int argc */
-#define requiredMemoryForExecutionContect(f, argc) \
-    sizeof(CallContext::Data) - sizeof(Value) + \
-    sizeof(Value) * (f->compiledFunction->nLocals + qMax((uint)argc, f->nFormals)) + sizeof(CallData)
-
 Heap::CallContext *ExecutionContext::newCallContext(Function *function, CallData *callData)
 {
-    Heap::CallContext *c = d()->engine->memoryManager->allocManaged<CallContext>(
-                requiredMemoryForExecutionContect(function, callData->argc));
+    uint localsAndFormals = function->compiledFunction->nLocals + qMax(static_cast<uint>(callData->argc), function->nFormals);
+    size_t requiredMemory = sizeof(CallContext::Data) - sizeof(Value) + \
+            sizeof(Value) * (localsAndFormals) + sizeof(CallData) - sizeof(Value);
+
+    Heap::CallContext *c = d()->engine->memoryManager->allocManaged<CallContext>(requiredMemory);
     c->init(d()->engine, Heap::ExecutionContext::Type_CallContext);
 
     c->v4Function = function;
@@ -75,36 +74,25 @@ Heap::CallContext *ExecutionContext::newCallContext(Function *function, CallData
     c->strictMode = function->isStrict();
     c->outer = this->d();
 
-    c->activation = 0;
-
     c->compilationUnit = function->compilationUnit;
     c->lookups = c->compilationUnit->runtimeLookups;
     c->constantTable = c->compilationUnit->constants;
 
     const CompiledData::Function *compiledFunction = function->compiledFunction;
-    int nLocals = compiledFunction->nLocals;
+    uint nLocals = compiledFunction->nLocals;
+    c->locals.size = nLocals;
+    c->locals.alloc = localsAndFormals;
     if (nLocals)
-        std::fill(c->locals, c->locals + nLocals, Primitive::undefinedValue());
+        std::fill(c->locals.v, c->locals.v + nLocals, Primitive::undefinedValue());
 
-    c->callData = reinterpret_cast<CallData *>(c->locals + nLocals);
-    ::memcpy(c->callData, callData, sizeof(CallData) + (callData->argc - 1) * sizeof(Value));
+    c->callData = reinterpret_cast<CallData *>(c->locals.v + nLocals);
+    ::memcpy(c->callData, callData, sizeof(CallData) - sizeof(Value) + static_cast<uint>(callData->argc) * sizeof(Value));
     if (callData->argc < static_cast<int>(compiledFunction->nFormals))
         std::fill(c->callData->args + c->callData->argc, c->callData->args + compiledFunction->nFormals, Primitive::undefinedValue());
 
     return c;
 }
 
-Heap::CallContext *Heap::CallContext::createSimpleContext(ExecutionEngine *v4)
-{
-    Heap::CallContext *ctxt = v4->memoryManager->allocSimpleCallContext(v4);
-    return ctxt;
-}
-
-void Heap::CallContext::freeSimpleCallContext()
-{
-    engine->memoryManager->freeSimpleCallContext();
-}
-
 Heap::WithContext *ExecutionContext::newWithContext(Heap::Object *with)
 {
     return d()->engine->memoryManager->alloc<WithContext>(d(), with);
@@ -128,7 +116,7 @@ void ExecutionContext::createMutableBinding(String *name, bool deletable)
         switch (ctx->d()->type) {
         case Heap::ExecutionContext::Type_CallContext:
         case Heap::ExecutionContext::Type_SimpleCallContext: {
-            Heap::CallContext *c = static_cast<Heap::CallContext *>(ctx->d());
+            Heap::SimpleCallContext *c = static_cast<Heap::SimpleCallContext *>(ctx->d());
             if (!activation) {
                 if (!c->activation)
                     c->activation = scope.engine->newObject();
@@ -184,22 +172,22 @@ void Heap::CatchContext::init(ExecutionContext *outerContext, String *exceptionV
 }
 
 
-Identifier * const *CallContext::formals() const
+Identifier * const *SimpleCallContext::formals() const
 {
     return d()->v4Function ? d()->v4Function->internalClass->nameMap.constData() : 0;
 }
 
-unsigned int CallContext::formalCount() const
+unsigned int SimpleCallContext::formalCount() const
 {
     return d()->v4Function ? d()->v4Function->nFormals : 0;
 }
 
-Identifier * const *CallContext::variables() const
+Identifier * const *SimpleCallContext::variables() const
 {
     return d()->v4Function ? d()->v4Function->internalClass->nameMap.constData() + d()->v4Function->nFormals : 0;
 }
 
-unsigned int CallContext::variableCount() const
+unsigned int SimpleCallContext::variableCount() const
 {
     return d()->v4Function ? d()->v4Function->compiledFunction->nLocals : 0;
 }
@@ -234,7 +222,7 @@ bool ExecutionContext::deleteProperty(String *name)
         }
         case Heap::ExecutionContext::Type_CallContext:
         case Heap::ExecutionContext::Type_SimpleCallContext: {
-            Heap::CallContext *c = static_cast<Heap::CallContext *>(ctx->d());
+            Heap::SimpleCallContext *c = static_cast<Heap::SimpleCallContext *>(ctx->d());
             if (c->v4Function && (c->v4Function->needsActivation() || hasWith)) {
                 uint index = c->v4Function->internalClass->find(name);
                 if (index < UINT_MAX)
@@ -257,30 +245,6 @@ bool ExecutionContext::deleteProperty(String *name)
     return true;
 }
 
-bool CallContext::needsOwnArguments() const
-{
-    QV4::Function *f = d()->v4Function;
-    return (f && f->needsActivation()) || (argc() < (f ? static_cast<int>(f->nFormals) : 0));
-}
-
-void CallContext::markObjects(Heap::Base *m, ExecutionEngine *engine)
-{
-    QV4::Heap::CallContext *ctx = static_cast<Heap::CallContext *>(m);
-
-    if (ctx->type == Heap::ExecutionContext::Type_CallContext) {
-        Q_ASSERT(ctx->v4Function);
-        ctx->callData->thisObject.mark(engine);
-        for (int arg = 0; arg < qMax(ctx->callData->argc, (int)ctx->v4Function->nFormals); ++arg)
-            ctx->callData->args[arg].mark(engine);
-        for (unsigned local = 0, lastLocal = ctx->v4Function->compiledFunction->nLocals; local < lastLocal; ++local)
-            ctx->locals[local].mark(engine);
-        if (ctx->activation)
-            ctx->activation->mark(engine);
-        if (ctx->function)
-            ctx->function->mark(engine);
-    }
-}
-
 // Do a standard call with this execution context as the outer scope
 void ExecutionContext::call(Scope &scope, CallData *callData, Function *function, const FunctionObject *f)
 {
@@ -304,7 +268,7 @@ void QV4::ExecutionContext::simpleCall(Scope &scope, CallData *callData, Functio
 
     ExecutionContextSaver ctxSaver(scope);
 
-    CallContext::Data *ctx = scope.engine->memoryManager->allocSimpleCallContext(scope.engine);
+    SimpleCallContext::Data *ctx = scope.engine->memoryManager->allocSimpleCallContext(scope.engine);
 
     ctx->strictMode = function->isStrict();
     ctx->callData = callData;
@@ -357,15 +321,16 @@ void ExecutionContext::setProperty(String *name, const Value &value)
         }
         case Heap::ExecutionContext::Type_CallContext:
         case Heap::ExecutionContext::Type_SimpleCallContext: {
-            Heap::CallContext *c = static_cast<Heap::CallContext *>(ctx->d());
+            Heap::SimpleCallContext *c = static_cast<Heap::SimpleCallContext *>(ctx->d());
             if (c->v4Function) {
                 uint index = c->v4Function->internalClass->find(name);
                 if (index < UINT_MAX) {
                     if (index < c->v4Function->nFormals) {
                         c->callData->args[c->v4Function->nFormals - index - 1] = value;
                     } else {
+                        Q_ASSERT(c->type = Heap::ExecutionContext::Type_CallContext);
                         index -= c->v4Function->nFormals;
-                        c->locals[index] = value;
+                        static_cast<Heap::CallContext *>(c)->locals[index] = value;
                     }
                     return;
                 }
@@ -438,13 +403,14 @@ ReturnedValue ExecutionContext::getProperty(String *name)
         }
         case Heap::ExecutionContext::Type_CallContext:
         case Heap::ExecutionContext::Type_SimpleCallContext: {
-            Heap::CallContext *c = static_cast<Heap::CallContext *>(ctx->d());
+            Heap::SimpleCallContext *c = static_cast<Heap::SimpleCallContext *>(ctx->d());
             if (c->v4Function && (c->v4Function->needsActivation() || hasWith || hasCatchScope)) {
                 uint index = c->v4Function->internalClass->find(name);
                 if (index < UINT_MAX) {
                     if (index < c->v4Function->nFormals)
                         return c->callData->args[c->v4Function->nFormals - index - 1].asReturnedValue();
-                    return c->locals[index - c->v4Function->nFormals].asReturnedValue();
+                    Q_ASSERT(c->type = Heap::ExecutionContext::Type_CallContext);
+                    return static_cast<Heap::CallContext *>(c)->locals[index - c->v4Function->nFormals].asReturnedValue();
                 }
             }
             ScopedObject activation(scope, c->activation);
@@ -454,9 +420,12 @@ ReturnedValue ExecutionContext::getProperty(String *name)
                 if (hasProperty)
                     return v->asReturnedValue();
             }
-            if (c->function && c->v4Function->isNamedExpression()
-                && name->equals(ScopedString(scope, c->v4Function->name())))
-                return c->function->asReturnedValue();
+            if (c->v4Function->isNamedExpression()) {
+                Q_ASSERT(c->type == Heap::CallContext::Type_CallContext);
+                Heap::CallContext *ctx = static_cast<Heap::CallContext *>(c);
+                if (ctx->function && name->equals(ScopedString(scope, c->v4Function->name())))
+                    return ctx->function->asReturnedValue();
+            }
             break;
         }
         case Heap::ExecutionContext::Type_QmlContext: {
@@ -516,13 +485,15 @@ ReturnedValue ExecutionContext::getPropertyAndBase(String *name, Value *base)
         }
         case Heap::ExecutionContext::Type_CallContext:
         case Heap::ExecutionContext::Type_SimpleCallContext: {
-            Heap::CallContext *c = static_cast<Heap::CallContext *>(ctx->d());
+            Heap::SimpleCallContext *c = static_cast<Heap::SimpleCallContext *>(ctx->d());
             if (c->v4Function && (c->v4Function->needsActivation() || hasWith || hasCatchScope)) {
+                Q_ASSERT(c->type == Heap::CallContext::Type_CallContext);
+                Heap::CallContext *ctx = static_cast<Heap::CallContext *>(c);
                 uint index = c->v4Function->internalClass->find(name);
                 if (index < UINT_MAX) {
                     if (index < c->v4Function->nFormals)
                         return c->callData->args[c->v4Function->nFormals - index - 1].asReturnedValue();
-                    return c->locals[index - c->v4Function->nFormals].asReturnedValue();
+                    return ctx->locals[index - c->v4Function->nFormals].asReturnedValue();
                 }
             }
             ScopedObject activation(scope, c->activation);
@@ -532,9 +503,12 @@ ReturnedValue ExecutionContext::getPropertyAndBase(String *name, Value *base)
                 if (hasProperty)
                     return v->asReturnedValue();
             }
-            if (c->function && c->v4Function->isNamedExpression()
-                && name->equals(ScopedString(scope, c->v4Function->name())))
-                return c->function->asReturnedValue();
+            if (c->v4Function->isNamedExpression()) {
+                Q_ASSERT(c->type == Heap::CallContext::Type_CallContext);
+                Heap::CallContext *ctx = static_cast<Heap::CallContext *>(c);
+                if (ctx->function && name->equals(ScopedString(scope, c->v4Function->name())))
+                    return ctx->function->asReturnedValue();
+            }
             break;
         }
         case Heap::ExecutionContext::Type_QmlContext: {
@@ -558,7 +532,7 @@ Function *ExecutionContext::getFunction() const
     Scope scope(d()->engine);
     ScopedContext it(scope, this->d());
     for (; it; it = it->d()->outer) {
-        if (const CallContext *callCtx = it->asCallContext())
+        if (const SimpleCallContext *callCtx = it->asSimpleCallContext())
             return callCtx->d()->v4Function;
         else if (it->asCatchContext() || it->asWithContext())
             continue; // look in the parent context for a FunctionObject
diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h
index 96cdb90db9..3d4a9ba1d7 100644
--- a/src/qml/jsruntime/qv4context_p.h
+++ b/src/qml/jsruntime/qv4context_p.h
@@ -68,6 +68,7 @@ struct Function;
 struct Function;
 struct Identifier;
 struct CallContext;
+struct SimpleCallContext;
 struct CatchContext;
 struct WithContext;
 struct QmlContext;
@@ -131,14 +132,12 @@ DECLARE_HEAP_OBJECT(ExecutionContext, Base) {
 };
 V4_ASSERT_IS_TRIVIAL(ExecutionContext)
 
-#define CallContextMembers(class, Member) \
-    Member(class, Pointer<FunctionObject>, function) \
-    Member(class, Pointer<Object>, activation)
+#define SimpleCallContextMembers(class, Member) \
+    Member(class, Pointer<Object>, activation) \
+    Member(class, QV4::Function *, v4Function)
 
-DECLARE_HEAP_OBJECT(CallContext, ExecutionContext) {
-    DECLARE_MARK_TABLE(CallContext);
-    static CallContext *createSimpleContext(ExecutionEngine *v4);
-    void freeSimpleCallContext();
+DECLARE_HEAP_OBJECT(SimpleCallContext, ExecutionContext) {
+    DECLARE_MARK_TABLE(SimpleCallContext);
 
     void init(ExecutionEngine *engine, ContextType t = Type_SimpleCallContext)
     {
@@ -147,10 +146,18 @@ DECLARE_HEAP_OBJECT(CallContext, ExecutionContext) {
 
     inline unsigned int formalParameterCount() const;
 
-    QV4::Function *v4Function;
-    Value locals[1];
 };
-V4_ASSERT_IS_TRIVIAL(CallContext)
+V4_ASSERT_IS_TRIVIAL(SimpleCallContext)
+
+#define CallContextMembers(class, Member) \
+    Member(class, Pointer<FunctionObject>, function) \
+    Member(class, ValueArray, locals) \
+
+DECLARE_HEAP_OBJECT(CallContext, SimpleCallContext) {
+    DECLARE_MARK_TABLE(CallContext);
+
+    using SimpleCallContext::formalParameterCount;
+};
 
 #define GlobalContextMembers(class, Member) \
     Member(class, Pointer<Object>, global)
@@ -217,8 +224,8 @@ struct Q_QML_EXPORT ExecutionContext : public Managed
     ReturnedValue getPropertyAndBase(String *name, Value *base);
     bool deleteProperty(String *name);
 
-    inline CallContext *asCallContext();
-    inline const CallContext *asCallContext() const;
+    inline SimpleCallContext *asSimpleCallContext();
+    inline const SimpleCallContext *asSimpleCallContext() const;
     inline const CatchContext *asCatchContext() const;
     inline const WithContext *asWithContext() const;
 
@@ -241,9 +248,9 @@ struct Q_QML_EXPORT ExecutionContext : public Managed
     void simpleCall(Scope &scope, CallData *callData, QV4::Function *function);
 };
 
-struct Q_QML_EXPORT CallContext : public ExecutionContext
+struct Q_QML_EXPORT SimpleCallContext : public ExecutionContext
 {
-    V4_MANAGED(CallContext, ExecutionContext)
+    V4_MANAGED(SimpleCallContext, ExecutionContext)
 
     // formals are in reverse order
     Identifier * const *formals() const;
@@ -252,15 +259,17 @@ struct Q_QML_EXPORT CallContext : public ExecutionContext
     unsigned int variableCount() const;
 
     inline ReturnedValue argument(int i) const;
-    bool needsOwnArguments() const;
-
-    static void markObjects(Heap::Base *m, ExecutionEngine *e);
 };
 
-inline ReturnedValue CallContext::argument(int i) const {
+inline ReturnedValue SimpleCallContext::argument(int i) const {
     return i < argc() ? args()[i].asReturnedValue() : Primitive::undefinedValue().asReturnedValue();
 }
 
+struct Q_QML_EXPORT CallContext : public SimpleCallContext
+{
+    V4_MANAGED(CallContext, SimpleCallContext)
+};
+
 struct GlobalContext : public ExecutionContext
 {
     V4_MANAGED(GlobalContext, ExecutionContext)
@@ -277,14 +286,14 @@ struct WithContext : public ExecutionContext
     V4_MANAGED(WithContext, ExecutionContext)
 };
 
-inline CallContext *ExecutionContext::asCallContext()
+inline SimpleCallContext *ExecutionContext::asSimpleCallContext()
 {
-    return d()->type >= Heap::ExecutionContext::Type_SimpleCallContext ? static_cast<CallContext *>(this) : 0;
+    return d()->type >= Heap::ExecutionContext::Type_SimpleCallContext ? static_cast<SimpleCallContext *>(this) : 0;
 }
 
-inline const CallContext *ExecutionContext::asCallContext() const
+inline const SimpleCallContext *ExecutionContext::asSimpleCallContext() const
 {
-    return d()->type >= Heap::ExecutionContext::Type_SimpleCallContext ? static_cast<const CallContext *>(this) : 0;
+    return d()->type >= Heap::ExecutionContext::Type_SimpleCallContext ? static_cast<const SimpleCallContext *>(this) : 0;
 }
 
 inline const CatchContext *ExecutionContext::asCatchContext() const
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 19298f3803..bc618e3e7a 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -886,7 +886,7 @@ QUrl ExecutionEngine::resolvedUrl(const QString &file)
     QUrl base;
     ExecutionContext *c = currentContext;
     while (c) {
-        CallContext *callCtx = c->asCallContext();
+        SimpleCallContext *callCtx = c->asSimpleCallContext();
         if (callCtx && callCtx->d()->v4Function) {
             base.setUrl(callCtx->d()->v4Function->sourceFile());
             break;
diff --git a/src/qml/jsruntime/qv4function_p.h b/src/qml/jsruntime/qv4function_p.h
index 54d0528c42..ff5febd19c 100644
--- a/src/qml/jsruntime/qv4function_p.h
+++ b/src/qml/jsruntime/qv4function_p.h
@@ -102,7 +102,7 @@ struct Q_QML_EXPORT Function {
 };
 
 
-inline unsigned int Heap::CallContext::formalParameterCount() const
+inline unsigned int Heap::SimpleCallContext::formalParameterCount() const
 {
     return v4Function ? v4Function->nFormals : 0;
 }
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 94555a6679..9afea01141 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -472,7 +472,7 @@ void OldBuiltinFunction::call(const Managed *that, Scope &scope, CallData *callD
 
     ExecutionContextSaver ctxSaver(scope);
 
-    CallContext::Data *ctx = v4->memoryManager->allocSimpleCallContext(v4);
+    SimpleCallContext::Data *ctx = v4->memoryManager->allocSimpleCallContext(v4);
     ctx->strictMode = f->scope()->strictMode; // ### needed? scope or parent context?
     ctx->callData = callData;
     v4->pushContext(ctx);
@@ -519,7 +519,7 @@ void IndexedBuiltinFunction::call(const Managed *that, Scope &scope, CallData *c
 
     ExecutionContextSaver ctxSaver(scope);
 
-    CallContext::Data *ctx = v4->memoryManager->allocSimpleCallContext(v4);
+    SimpleCallContext::Data *ctx = v4->memoryManager->allocSimpleCallContext(v4);
     ctx->strictMode = f->scope()->strictMode; // ### needed? scope or parent context?
     ctx->callData = callData;
     v4->pushContext(ctx);
diff --git a/src/qml/jsruntime/qv4vme_moth.cpp b/src/qml/jsruntime/qv4vme_moth.cpp
index be2772c23f..8afeb5b4da 100644
--- a/src/qml/jsruntime/qv4vme_moth.cpp
+++ b/src/qml/jsruntime/qv4vme_moth.cpp
@@ -410,10 +410,14 @@ QV4::ReturnedValue VME::run(ExecutionEngine *engine, const uchar *code
         QV4::Heap::ExecutionContext *scope = context->d();
         int i = 0;
         while (scope) {
-            if (scope->type >= QV4::Heap::ExecutionContext::Type_SimpleCallContext) {
+            if (scope->type == QV4::Heap::ExecutionContext::Type_SimpleCallContext) {
+                QV4::Heap::SimpleCallContext *cc = static_cast<QV4::Heap::SimpleCallContext *>(scope);
+                scopes[2*i + 2] = cc->callData->args;
+                scopes[2*i + 3] = 0;
+            } else if (scope->type == QV4::Heap::ExecutionContext::Type_CallContext) {
                 QV4::Heap::CallContext *cc = static_cast<QV4::Heap::CallContext *>(scope);
                 scopes[2*i + 2] = cc->callData->args;
-                scopes[2*i + 3] = cc->locals;
+                scopes[2*i + 3] = cc->locals.v;
             } else {
                 scopes[2*i + 2] = 0;
                 scopes[2*i + 3] = 0;
diff --git a/src/qml/memory/qv4mm_p.h b/src/qml/memory/qv4mm_p.h
index 016879799a..0bd9229792 100644
--- a/src/qml/memory/qv4mm_p.h
+++ b/src/qml/memory/qv4mm_p.h
@@ -206,11 +206,11 @@ public:
     Q_DECL_CONSTEXPR static inline std::size_t align(std::size_t size)
     { return (size + Chunk::SlotSize - 1) & ~(Chunk::SlotSize - 1); }
 
-    QV4::Heap::CallContext *allocSimpleCallContext(QV4::ExecutionEngine *v4)
+    QV4::Heap::SimpleCallContext *allocSimpleCallContext(QV4::ExecutionEngine *v4)
     {
         Heap::CallContext *ctxt = stackAllocator.allocate();
-        memset(ctxt, 0, sizeof(Heap::CallContext));
-        ctxt->setVtable(QV4::CallContext::staticVTable());
+        memset(ctxt, 0, sizeof(Heap::SimpleCallContext));
+        ctxt->setVtable(QV4::SimpleCallContext::staticVTable());
         ctxt->init(v4);
         return ctxt;