Move more objects from the v4 engine to the js stack

Convert most of the prototype objects in the v4 engine.

Change-Id: I365f290493c20973bc991b6a383649836e42a16a
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>

17 files changed, 115 insertions, 116 deletions

diff --git a/src/qml/jsapi/qjsengine.cpp b/src/qml/jsapi/qjsengine.cpp
index 198c3c2b28..a02458b8bd 100644
--- a/src/qml/jsapi/qjsengine.cpp
+++ b/src/qml/jsapi/qjsengine.cpp
@@ -281,7 +281,7 @@ void QJSEngine::installTranslatorFunctions(const QJSValue &object)
     obj->defineDefaultProperty(QStringLiteral("QT_TRID_NOOP"), QV4::GlobalExtensions::method_qsTrIdNoOp);
 
     // string prototype extension
-    scope.engine->stringPrototype.as<QV4::Object>()->defineDefaultProperty(QStringLiteral("arg"),
+    scope.engine->stringPrototype()->defineDefaultProperty(QStringLiteral("arg"),
                                                           QV4::GlobalExtensions::method_string_arg);
 #endif
 }
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index 3c72afac40..87f45c460f 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -629,7 +629,7 @@ static double getLocalTZA()
 DEFINE_OBJECT_VTABLE(DateObject);
 
 Heap::DateObject::DateObject(QV4::ExecutionEngine *engine, const QDateTime &date)
-    : Heap::Object(engine->emptyClass, engine->datePrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->datePrototype())
 {
     this->date = date.isValid() ? date.toMSecsSinceEpoch() : qSNaN();
 }
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index 47029097a9..133a8d27e8 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -53,7 +53,7 @@ struct DateObject : Object {
     }
 
     DateObject(QV4::ExecutionEngine *engine, const Value &date)
-        : Object(engine->emptyClass, engine->datePrototype.objectValue())
+        : Object(engine->emptyClass, engine->datePrototype())
     {
         this->date = date.toNumber();
     }
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 480949b56c..388cb86688 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -286,7 +286,7 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     jsObjects[ObjectProto] = memoryManager->alloc<ObjectPrototype>(emptyClass, (QV4::Object *)0);
 
     arrayClass = emptyClass->addMember(id_length, Attr_NotConfigurable|Attr_NotEnumerable);
-    arrayPrototype = memoryManager->alloc<ArrayPrototype>(arrayClass, objectPrototype());
+    jsObjects[ArrayProto] = memoryManager->alloc<ArrayPrototype>(arrayClass, objectPrototype());
 
     InternalClass *argsClass = emptyClass->addMember(id_length, Attr_NotEnumerable);
     argumentsObjectClass = argsClass->addMember(id_callee, Attr_Data|Attr_NotEnumerable);
@@ -297,15 +297,15 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     Q_ASSERT(globalObject->d()->vtable);
     initRootContext();
 
-    stringPrototype = memoryManager->alloc<StringPrototype>(emptyClass, objectPrototype());
-    numberPrototype = memoryManager->alloc<NumberPrototype>(emptyClass, objectPrototype());
-    booleanPrototype = memoryManager->alloc<BooleanPrototype>(emptyClass, objectPrototype());
-    datePrototype = memoryManager->alloc<DatePrototype>(emptyClass, objectPrototype());
+    jsObjects[StringProto] = memoryManager->alloc<StringPrototype>(emptyClass, objectPrototype());
+    jsObjects[NumberProto] = memoryManager->alloc<NumberPrototype>(emptyClass, objectPrototype());
+    jsObjects[BooleanProto] = memoryManager->alloc<BooleanPrototype>(emptyClass, objectPrototype());
+    jsObjects[DateProto] = memoryManager->alloc<DatePrototype>(emptyClass, objectPrototype());
 
     uint index;
     InternalClass *functionProtoClass = emptyClass->addMember(id_prototype, Attr_NotEnumerable, &index);
     Q_ASSERT(index == Heap::FunctionObject::Index_Prototype);
-    functionPrototype = memoryManager->alloc<FunctionPrototype>(functionProtoClass, objectPrototype());
+    jsObjects[FunctionProto] = memoryManager->alloc<FunctionPrototype>(functionProtoClass, objectPrototype());
     functionClass = emptyClass->addMember(id_prototype, Attr_NotEnumerable|Attr_NotConfigurable, &index);
     Q_ASSERT(index == Heap::FunctionObject::Index_Prototype);
     simpleScriptFunctionClass = functionClass->addMember(id_name, Attr_ReadOnly, &index);
@@ -315,25 +315,25 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     protoClass = emptyClass->addMember(id_constructor, Attr_NotEnumerable, &index);
     Q_ASSERT(index == Heap::FunctionObject::Index_ProtoConstructor);
 
-    regExpPrototype = memoryManager->alloc<RegExpPrototype>(this);
+    jsObjects[RegExpProto] = memoryManager->alloc<RegExpPrototype>(this);
     regExpExecArrayClass = arrayClass->addMember(id_index, Attr_Data, &index);
     Q_ASSERT(index == RegExpObject::Index_ArrayIndex);
     regExpExecArrayClass = regExpExecArrayClass->addMember(id_input, Attr_Data, &index);
     Q_ASSERT(index == RegExpObject::Index_ArrayInput);
 
-    errorPrototype = memoryManager->alloc<ErrorPrototype>(emptyClass, objectPrototype());
-    evalErrorPrototype = memoryManager->alloc<EvalErrorPrototype>(emptyClass, errorPrototype.as<Object>());
-    rangeErrorPrototype = memoryManager->alloc<RangeErrorPrototype>(emptyClass, errorPrototype.as<Object>());
-    referenceErrorPrototype = memoryManager->alloc<ReferenceErrorPrototype>(emptyClass, errorPrototype.as<Object>());
-    syntaxErrorPrototype = memoryManager->alloc<SyntaxErrorPrototype>(emptyClass, errorPrototype.as<Object>());
-    typeErrorPrototype = memoryManager->alloc<TypeErrorPrototype>(emptyClass, errorPrototype.as<Object>());
-    uRIErrorPrototype = memoryManager->alloc<URIErrorPrototype>(emptyClass, errorPrototype.as<Object>());
+    jsObjects[ErrorProto] = memoryManager->alloc<ErrorPrototype>(emptyClass, objectPrototype());
+    jsObjects[EvalErrorProto] = memoryManager->alloc<EvalErrorPrototype>(emptyClass, errorPrototype());
+    jsObjects[RangeErrorProto] = memoryManager->alloc<RangeErrorPrototype>(emptyClass, errorPrototype());
+    jsObjects[ReferenceErrorProto] = memoryManager->alloc<ReferenceErrorPrototype>(emptyClass, errorPrototype());
+    jsObjects[SyntaxErrorProto] = memoryManager->alloc<SyntaxErrorPrototype>(emptyClass, errorPrototype());
+    jsObjects[TypeErrorProto] = memoryManager->alloc<TypeErrorPrototype>(emptyClass, errorPrototype());
+    jsObjects[URIErrorProto] = memoryManager->alloc<URIErrorPrototype>(emptyClass, errorPrototype());
 
-    variantPrototype = memoryManager->alloc<VariantPrototype>(emptyClass, objectPrototype());
-    Q_ASSERT(variantPrototype.as<Object>()->prototype() == objectPrototype()->d());
+    jsObjects[VariantProto] = memoryManager->alloc<VariantPrototype>(emptyClass, objectPrototype());
+    Q_ASSERT(variantPrototype()->prototype() == objectPrototype()->d());
 
     Scope scope(this);
-    sequencePrototype = ScopedValue(scope, memoryManager->alloc<SequencePrototype>(arrayClass, arrayPrototype.as<Object>()));
+    jsObjects[SequenceProto] = ScopedValue(scope, memoryManager->alloc<SequencePrototype>(arrayClass, arrayPrototype()));
 
     ScopedContext global(scope, rootContext());
     objectCtor = memoryManager->alloc<ObjectCtor>(global);
@@ -353,23 +353,23 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     uRIErrorCtor = memoryManager->alloc<URIErrorCtor>(global);
 
     static_cast<ObjectPrototype *>(objectPrototype())->init(this, objectCtor.as<Object>());
-    static_cast<StringPrototype *>(stringPrototype.as<Object>())->init(this, stringCtor.as<Object>());
-    static_cast<NumberPrototype *>(numberPrototype.as<Object>())->init(this, numberCtor.as<Object>());
-    static_cast<BooleanPrototype *>(booleanPrototype.as<Object>())->init(this, booleanCtor.as<Object>());
-    static_cast<ArrayPrototype *>(arrayPrototype.as<Object>())->init(this, arrayCtor.as<Object>());
-    static_cast<DatePrototype *>(datePrototype.as<Object>())->init(this, dateCtor.as<Object>());
-    static_cast<FunctionPrototype *>(functionPrototype.as<Object>())->init(this, functionCtor.as<Object>());
-    static_cast<RegExpPrototype *>(regExpPrototype.as<Object>())->init(this, regExpCtor.as<Object>());
-    static_cast<ErrorPrototype *>(errorPrototype.as<Object>())->init(this, errorCtor.as<Object>());
-    static_cast<EvalErrorPrototype *>(evalErrorPrototype.as<Object>())->init(this, evalErrorCtor.as<Object>());
-    static_cast<RangeErrorPrototype *>(rangeErrorPrototype.as<Object>())->init(this, rangeErrorCtor.as<Object>());
-    static_cast<ReferenceErrorPrototype *>(referenceErrorPrototype.as<Object>())->init(this, referenceErrorCtor.as<Object>());
-    static_cast<SyntaxErrorPrototype *>(syntaxErrorPrototype.as<Object>())->init(this, syntaxErrorCtor.as<Object>());
-    static_cast<TypeErrorPrototype *>(typeErrorPrototype.as<Object>())->init(this, typeErrorCtor.as<Object>());
-    static_cast<URIErrorPrototype *>(uRIErrorPrototype.as<Object>())->init(this, uRIErrorCtor.as<Object>());
-
-    static_cast<VariantPrototype *>(variantPrototype.as<Object>())->init();
-    sequencePrototype.cast<SequencePrototype>()->init();
+    static_cast<StringPrototype *>(stringPrototype())->init(this, stringCtor.as<Object>());
+    static_cast<NumberPrototype *>(numberPrototype())->init(this, numberCtor.as<Object>());
+    static_cast<BooleanPrototype *>(booleanPrototype())->init(this, booleanCtor.as<Object>());
+    static_cast<ArrayPrototype *>(arrayPrototype())->init(this, arrayCtor.as<Object>());
+    static_cast<DatePrototype *>(datePrototype())->init(this, dateCtor.as<Object>());
+    static_cast<FunctionPrototype *>(functionPrototype())->init(this, functionCtor.as<Object>());
+    static_cast<RegExpPrototype *>(regExpPrototype())->init(this, regExpCtor.as<Object>());
+    static_cast<ErrorPrototype *>(errorPrototype())->init(this, errorCtor.as<Object>());
+    static_cast<EvalErrorPrototype *>(evalErrorPrototype())->init(this, evalErrorCtor.as<Object>());
+    static_cast<RangeErrorPrototype *>(rangeErrorPrototype())->init(this, rangeErrorCtor.as<Object>());
+    static_cast<ReferenceErrorPrototype *>(referenceErrorPrototype())->init(this, referenceErrorCtor.as<Object>());
+    static_cast<SyntaxErrorPrototype *>(syntaxErrorPrototype())->init(this, syntaxErrorCtor.as<Object>());
+    static_cast<TypeErrorPrototype *>(typeErrorPrototype())->init(this, typeErrorCtor.as<Object>());
+    static_cast<URIErrorPrototype *>(uRIErrorPrototype())->init(this, uRIErrorCtor.as<Object>());
+
+    static_cast<VariantPrototype *>(variantPrototype())->init();
+    sequencePrototype()->cast<SequencePrototype>()->init();
 
 
     // typed arrays
@@ -641,7 +641,7 @@ Heap::RegExpObject *ExecutionEngine::newRegExpObject(const QRegExp &re)
 Heap::Object *ExecutionEngine::newErrorObject(const Value &value)
 {
     Scope scope(this);
-    ScopedObject object(scope, memoryManager->alloc<ErrorObject>(emptyClass, errorPrototype.as<Object>(), value));
+    ScopedObject object(scope, memoryManager->alloc<ErrorObject>(emptyClass, errorPrototype(), value));
     return object->d();
 }
 
@@ -952,23 +952,6 @@ void ExecutionEngine::markObjects()
     for (int i = 0; i < Heap::TypedArray::NTypes; ++i)
         typedArrayCtors[i].mark(this);
 
-    arrayPrototype.mark(this);
-    stringPrototype.mark(this);
-    numberPrototype.mark(this);
-    booleanPrototype.mark(this);
-    datePrototype.mark(this);
-    functionPrototype.mark(this);
-    regExpPrototype.mark(this);
-    errorPrototype.mark(this);
-    evalErrorPrototype.mark(this);
-    rangeErrorPrototype.mark(this);
-    referenceErrorPrototype.mark(this);
-    syntaxErrorPrototype.mark(this);
-    typeErrorPrototype.mark(this);
-    uRIErrorPrototype.mark(this);
-    variantPrototype.mark(this);
-    sequencePrototype.mark(this);
-
     arrayBufferPrototype.mark(this);
     dataViewPrototype.mark(this);
     for (int i = 0; i < Heap::TypedArray::NTypes; ++i)
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index a71491ac32..f3c20d6336 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -130,6 +130,22 @@ public:
 
     enum JSObjects {
         ObjectProto,
+        ArrayProto,
+        StringProto,
+        NumberProto,
+        BooleanProto,
+        DateProto,
+        FunctionProto,
+        RegExpProto,
+        ErrorProto,
+        EvalErrorProto,
+        RangeErrorProto,
+        ReferenceErrorProto,
+        SyntaxErrorProto,
+        TypeErrorProto,
+        URIErrorProto,
+        VariantProto,
+        SequenceProto,
         NJSObjects
     };
     Value *jsObjects;
@@ -154,23 +170,23 @@ public:
     enum { NTypedArrayTypes = 9 }; // avoid header dependency
     Value typedArrayCtors[NTypedArrayTypes];
 
-    Object *objectPrototype() { return reinterpret_cast<Object *>(jsObjects + ObjectProto); }
-    Value arrayPrototype;
-    Value stringPrototype;
-    Value numberPrototype;
-    Value booleanPrototype;
-    Value datePrototype;
-    Value functionPrototype;
-    Value regExpPrototype;
-    Value errorPrototype;
-    Value evalErrorPrototype;
-    Value rangeErrorPrototype;
-    Value referenceErrorPrototype;
-    Value syntaxErrorPrototype;
-    Value typeErrorPrototype;
-    Value uRIErrorPrototype;
-    Value variantPrototype;
-    Value sequencePrototype;
+    Object *objectPrototype() const { return reinterpret_cast<Object *>(jsObjects + ObjectProto); }
+    Object *arrayPrototype() const { return reinterpret_cast<Object *>(jsObjects + ArrayProto); }
+    Object *stringPrototype() const { return reinterpret_cast<Object *>(jsObjects + StringProto); }
+    Object *numberPrototype() const { return reinterpret_cast<Object *>(jsObjects + NumberProto); }
+    Object *booleanPrototype() const { return reinterpret_cast<Object *>(jsObjects + BooleanProto); }
+    Object *datePrototype() const { return reinterpret_cast<Object *>(jsObjects + DateProto); }
+    Object *functionPrototype() const { return reinterpret_cast<Object *>(jsObjects + FunctionProto); }
+    Object *regExpPrototype() const { return reinterpret_cast<Object *>(jsObjects + RegExpProto); }
+    Object *errorPrototype() const { return reinterpret_cast<Object *>(jsObjects + ErrorProto); }
+    Object *evalErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + EvalErrorProto); }
+    Object *rangeErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + RangeErrorProto); }
+    Object *referenceErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + ReferenceErrorProto); }
+    Object *syntaxErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + SyntaxErrorProto); }
+    Object *typeErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + TypeErrorProto); }
+    Object *uRIErrorPrototype() const { return reinterpret_cast<Object *>(jsObjects + URIErrorProto); }
+    Object *variantPrototype() const { return reinterpret_cast<Object *>(jsObjects + VariantProto); }
+    Object *sequencePrototype() const { return reinterpret_cast<Object *>(jsObjects + SequenceProto); }
 
     Value arrayBufferPrototype;
     Value dataViewPrototype;
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index 1f7999fe4a..2f9e09205a 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -182,57 +182,57 @@ DEFINE_OBJECT_VTABLE(ErrorObject);
 DEFINE_OBJECT_VTABLE(SyntaxErrorObject);
 
 Heap::SyntaxErrorObject::SyntaxErrorObject(ExecutionEngine *engine, const Value &msg)
-    : Heap::ErrorObject(engine->emptyClass, engine->syntaxErrorPrototype.objectValue(), msg, SyntaxError)
+    : Heap::ErrorObject(engine->emptyClass, engine->syntaxErrorPrototype(), msg, SyntaxError)
 {
 }
 
 Heap::SyntaxErrorObject::SyntaxErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : Heap::ErrorObject(engine->emptyClass, engine->syntaxErrorPrototype.objectValue(), msg, fileName, lineNumber, columnNumber, SyntaxError)
+    : Heap::ErrorObject(engine->emptyClass, engine->syntaxErrorPrototype(), msg, fileName, lineNumber, columnNumber, SyntaxError)
 {
 }
 
 Heap::EvalErrorObject::EvalErrorObject(ExecutionEngine *engine, const Value &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->evalErrorPrototype.objectValue(), message, EvalError)
+    : Heap::ErrorObject(engine->emptyClass, engine->evalErrorPrototype(), message, EvalError)
 {
 }
 
 Heap::RangeErrorObject::RangeErrorObject(ExecutionEngine *engine, const Value &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->rangeErrorPrototype.objectValue(), message, RangeError)
+    : Heap::ErrorObject(engine->emptyClass, engine->rangeErrorPrototype(), message, RangeError)
 {
 }
 
 Heap::RangeErrorObject::RangeErrorObject(ExecutionEngine *engine, const QString &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->rangeErrorPrototype.objectValue(), message, RangeError)
+    : Heap::ErrorObject(engine->emptyClass, engine->rangeErrorPrototype(), message, RangeError)
 {
 }
 
 Heap::ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const Value &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype.objectValue(), message, ReferenceError)
+    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype(), message, ReferenceError)
 {
 }
 
 Heap::ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const QString &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype.objectValue(), message, ReferenceError)
+    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype(), message, ReferenceError)
 {
 }
 
 Heap::ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype.objectValue(), msg, fileName, lineNumber, columnNumber, ReferenceError)
+    : Heap::ErrorObject(engine->emptyClass, engine->referenceErrorPrototype(), msg, fileName, lineNumber, columnNumber, ReferenceError)
 {
 }
 
 Heap::TypeErrorObject::TypeErrorObject(ExecutionEngine *engine, const Value &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->typeErrorPrototype.objectValue(), message, TypeError)
+    : Heap::ErrorObject(engine->emptyClass, engine->typeErrorPrototype(), message, TypeError)
 {
 }
 
 Heap::TypeErrorObject::TypeErrorObject(ExecutionEngine *engine, const QString &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->typeErrorPrototype.objectValue(), message, TypeError)
+    : Heap::ErrorObject(engine->emptyClass, engine->typeErrorPrototype(), message, TypeError)
 {
 }
 
 Heap::URIErrorObject::URIErrorObject(ExecutionEngine *engine, const Value &message)
-    : Heap::ErrorObject(engine->emptyClass, engine->uRIErrorPrototype.objectValue(), message, URIError)
+    : Heap::ErrorObject(engine->emptyClass, engine->uRIErrorPrototype(), message, URIError)
 {
 }
 
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 2c8da4c943..ca4617693f 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -63,7 +63,7 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(FunctionObject);
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, QV4::String *name, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -73,7 +73,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, QV4::String *
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *function, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -84,7 +84,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *fun
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString &name, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -95,7 +95,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString
 }
 
 Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &name, bool createProto)
-    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype())
     , scope(scope)
     , function(Q_NULLPTR)
 {
@@ -106,7 +106,7 @@ Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &nam
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const ReturnedValue name)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -117,7 +117,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const Returne
 }
 
 Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const ReturnedValue name)
-    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype.objectValue())
+    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype())
     , scope(scope)
     , function(Q_NULLPTR)
 {
@@ -465,7 +465,7 @@ ReturnedValue ScriptFunction::call(const Managed *that, CallData *callData)
 DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
 
 Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, Function *function, bool createProto)
-    : Heap::FunctionObject(function->compilationUnit->engine->simpleScriptFunctionClass, function->compilationUnit->engine->functionPrototype.as<QV4::Object>())
+    : Heap::FunctionObject(function->compilationUnit->engine->simpleScriptFunctionClass, function->compilationUnit->engine->functionPrototype())
 {
     this->scope = scope->d();
 
diff --git a/src/qml/jsruntime/qv4lookup.cpp b/src/qml/jsruntime/qv4lookup.cpp
index c75309a30b..3cc77d2e3d 100644
--- a/src/qml/jsruntime/qv4lookup.cpp
+++ b/src/qml/jsruntime/qv4lookup.cpp
@@ -245,11 +245,11 @@ ReturnedValue Lookup::getterGeneric(Lookup *l, ExecutionEngine *engine, const Va
     case Value::Null_Type:
         return engine->throwTypeError();
     case Value::Boolean_Type:
-        proto = engine->booleanPrototype.as<Object>();
+        proto = engine->booleanPrototype();
         break;
     case Value::Managed_Type: {
         Q_ASSERT(object.isString());
-        proto = engine->stringPrototype.as<Object>();
+        proto = engine->stringPrototype();
         Scope scope(engine);
         ScopedString name(scope, engine->currentContext()->compilationUnit->runtimeStrings[l->nameIndex]);
         if (name->equals(engine->id_length)) {
@@ -261,7 +261,7 @@ ReturnedValue Lookup::getterGeneric(Lookup *l, ExecutionEngine *engine, const Va
     }
     case Value::Integer_Type:
     default: // Number
-        proto = engine->numberPrototype.as<Object>();
+        proto = engine->numberPrototype();
     }
 
     PropertyAttributes attrs;
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index 0317ee435f..148c7829bd 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -1138,7 +1138,7 @@ void Object::initSparseArray()
 DEFINE_OBJECT_VTABLE(ArrayObject);
 
 Heap::ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list)
-    : Heap::Object(engine->arrayClass, engine->arrayPrototype.objectValue())
+    : Heap::Object(engine->arrayClass, engine->arrayPrototype())
 {
     init();
     Scope scope(engine);
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index 3375b16116..e5055e20c0 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -344,7 +344,7 @@ struct BooleanObject : Object {
     }
 
     BooleanObject(ExecutionEngine *engine, bool b)
-        : Object(engine->emptyClass, engine->booleanPrototype.objectValue()),
+        : Object(engine->emptyClass, engine->booleanPrototype()),
           b(b)
     {
     }
@@ -359,7 +359,7 @@ struct NumberObject : Object {
     }
 
     NumberObject(ExecutionEngine *engine, double val)
-        : Object(engine->emptyClass, engine->numberPrototype.objectValue()),
+        : Object(engine->emptyClass, engine->numberPrototype()),
           value(val)
     {
     }
@@ -372,7 +372,7 @@ struct ArrayObject : Object {
     };
 
     ArrayObject(ExecutionEngine *engine)
-        : Heap::Object(engine->arrayClass, engine->arrayPrototype.objectValue())
+        : Heap::Object(engine->arrayClass, engine->arrayPrototype())
     { init(); }
     ArrayObject(ExecutionEngine *engine, const QStringList &list);
     ArrayObject(InternalClass *ic, QV4::Object *prototype)
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index d8c8cbe42c..1a511cf5e0 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -241,8 +241,8 @@ Heap::QObjectWrapper::QObjectWrapper(ExecutionEngine *engine, QObject *object)
 
 void QObjectWrapper::initializeBindings(ExecutionEngine *engine)
 {
-    engine->functionPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("connect"), method_connect);
-    engine->functionPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("disconnect"), method_disconnect);
+    engine->functionPrototype()->defineDefaultProperty(QStringLiteral("connect"), method_connect);
+    engine->functionPrototype()->defineDefaultProperty(QStringLiteral("disconnect"), method_disconnect);
 }
 
 QQmlPropertyData *QObjectWrapper::findProperty(ExecutionEngine *engine, QQmlContextData *qmlContext, String *name, RevisionMode revisionMode, QQmlPropertyData *local) const
@@ -347,8 +347,8 @@ ReturnedValue QObjectWrapper::getProperty(QObject *object, ExecutionContext *ctx
 
             QV4::ScopedString connect(scope, ctx->d()->engine->newIdentifier(QStringLiteral("connect")));
             QV4::ScopedString disconnect(scope, ctx->d()->engine->newIdentifier(QStringLiteral("disconnect")));
-            handler->put(connect, QV4::ScopedValue(scope, ctx->d()->engine->functionPrototype.as<Object>()->get(connect)));
-            handler->put(disconnect, QV4::ScopedValue(scope, ctx->d()->engine->functionPrototype.as<Object>()->get(disconnect)));
+            handler->put(connect, QV4::ScopedValue(scope, ctx->d()->engine->functionPrototype()->get(connect)));
+            handler->put(disconnect, QV4::ScopedValue(scope, ctx->d()->engine->functionPrototype()->get(disconnect)));
 
             return handler.asReturnedValue();
         } else {
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index 06d9a6da67..077ac991a9 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -75,7 +75,7 @@ Heap::RegExpObject::RegExpObject(InternalClass *ic, QV4::Object *prototype)
 }
 
 Heap::RegExpObject::RegExpObject(QV4::ExecutionEngine *engine, QV4::RegExp *value, bool global)
-    : Heap::Object(engine->emptyClass, engine->regExpPrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->regExpPrototype())
     , value(value->d())
     , global(global)
 {
@@ -88,7 +88,7 @@ Heap::RegExpObject::RegExpObject(QV4::ExecutionEngine *engine, QV4::RegExp *valu
 // The conversion is not 100% exact since ECMA regexp and QRegExp
 // have different semantics/flags, but we try to do our best.
 Heap::RegExpObject::RegExpObject(QV4::ExecutionEngine *engine, const QRegExp &re)
-    : Heap::Object(engine->emptyClass, engine->regExpPrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->regExpPrototype())
 {
     value = 0;
     global = false;
@@ -372,7 +372,7 @@ ReturnedValue RegExpPrototype::method_exec(CallContext *ctx)
     }
 
     // fill in result data
-    ScopedArrayObject array(scope, scope.engine->newArrayObject(scope.engine->regExpExecArrayClass, scope.engine->arrayPrototype.as<Object>()));
+    ScopedArrayObject array(scope, scope.engine->newArrayObject(scope.engine->regExpExecArrayClass, scope.engine->arrayPrototype()));
     int len = r->value()->captureCount();
     array->arrayReserve(len);
     ScopedValue v(scope);
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 1d16900b78..cd66f2942b 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -544,7 +544,7 @@ public:
 
 template <typename Container>
 Heap::QQmlSequence<Container>::QQmlSequence(QV4::ExecutionEngine *engine, const Container &container)
-    : Heap::Object(engine->emptyClass, engine->sequencePrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->sequencePrototype())
     , container(container)
     , propertyIndex(-1)
     , isReference(false)
@@ -557,7 +557,7 @@ Heap::QQmlSequence<Container>::QQmlSequence(QV4::ExecutionEngine *engine, const
 
 template <typename Container>
 Heap::QQmlSequence<Container>::QQmlSequence(QV4::ExecutionEngine *engine, QObject *object, int propertyIndex)
-    : Heap::Object(engine->emptyClass, engine->sequencePrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->sequencePrototype())
     , object(object)
     , propertyIndex(propertyIndex)
     , isReference(true)
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index f4a6e455cd..e46bbfe7d6 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -80,7 +80,7 @@ Heap::StringObject::StringObject(InternalClass *ic, QV4::Object *prototype)
 }
 
 Heap::StringObject::StringObject(ExecutionEngine *engine, const Value &val)
-    : Heap::Object(engine->emptyClass, engine->stringPrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->stringPrototype())
 {
     value = val;
     Q_ASSERT(value.isString());
@@ -379,7 +379,7 @@ ReturnedValue StringPrototype::method_match(CallContext *context)
 
     // ### use the standard builtin function, not the one that might be redefined in the proto
     ScopedString execString(scope, scope.engine->newString(QStringLiteral("exec")));
-    ScopedFunctionObject exec(scope, scope.engine->regExpPrototype.as<Object>()->get(execString));
+    ScopedFunctionObject exec(scope, scope.engine->regExpPrototype()->get(execString));
 
     ScopedCallData callData(scope, 1);
     callData->thisObject = rx;
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index d862c12ba8..cd82159082 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -44,7 +44,7 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(VariantObject);
 
 Heap::VariantObject::VariantObject(QV4::ExecutionEngine *engine, const QVariant &value)
-    : Heap::Object(engine->emptyClass, engine->variantPrototype.objectValue())
+    : Heap::Object(engine->emptyClass, engine->variantPrototype())
 {
     data = value;
     if (isScarce())
diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp
index 2c05ffcea9..f5407d5669 100644
--- a/src/qml/qml/qqmllocale.cpp
+++ b/src/qml/qml/qqmllocale.cpp
@@ -65,9 +65,9 @@ static bool isLocaleObject(const QV4::Value &val)
 
 void QQmlDateExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->datePrototype.as<Object>()->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
-    engine->datePrototype.as<Object>()->defineDefaultProperty(QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString);
-    engine->datePrototype.as<Object>()->defineDefaultProperty(QStringLiteral("toLocaleDateString"), method_toLocaleDateString);
+    engine->datePrototype()->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->datePrototype()->defineDefaultProperty(QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString);
+    engine->datePrototype()->defineDefaultProperty(QStringLiteral("toLocaleDateString"), method_toLocaleDateString);
     engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleString"), method_fromLocaleString);
     engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleTimeString"), method_fromLocaleTimeString);
     engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleDateString"), method_fromLocaleDateString);
@@ -347,8 +347,8 @@ QV4::ReturnedValue QQmlDateExtension::method_timeZoneUpdated(QV4::CallContext *c
 
 void QQmlNumberExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->numberPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
-    engine->numberPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("toLocaleCurrencyString"), method_toLocaleCurrencyString);
+    engine->numberPrototype()->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->numberPrototype()->defineDefaultProperty(QStringLiteral("toLocaleCurrencyString"), method_toLocaleCurrencyString);
     engine->numberCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleString"), method_fromLocaleString);
 }
 
@@ -815,7 +815,7 @@ QV4::ReturnedValue QQmlLocale::wrap(ExecutionEngine *v4, const QLocale &locale)
 
 void QQmlLocale::registerStringLocaleCompare(QV4::ExecutionEngine *engine)
 {
-    engine->stringPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("localeCompare"), method_localeCompare);
+    engine->stringPrototype()->defineDefaultProperty(QStringLiteral("localeCompare"), method_localeCompare);
 }
 
 QV4::ReturnedValue QQmlLocale::method_localeCompare(QV4::CallContext *ctx)
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 33c687dcd0..17dfeea168 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -1613,7 +1613,7 @@ void QV4::GlobalExtensions::init(QQmlEngine *qmlEngine, Object *globalObject)
     globalObject->defineDefaultProperty(QStringLiteral("Qt"), qt);
 
     // string prototype extension
-    v4->stringPrototype.as<Object>()->defineDefaultProperty(QStringLiteral("arg"), method_string_arg);
+    v4->stringPrototype()->defineDefaultProperty(QStringLiteral("arg"), method_string_arg);
 }