1 files changed, 33 insertions, 15 deletions

diff --git a/src/qml/jsruntime/qv4function_p.h b/src/qml/jsruntime/qv4function_p.h
index 181c88a1e2..7543dd3c4b 100644
--- a/src/qml/jsruntime/qv4function_p.h
+++ b/src/qml/jsruntime/qv4function_p.h
@@ -30,16 +30,15 @@ struct QQmlSourceLocation;
 
 namespace QV4 {
 
-struct Q_QML_EXPORT FunctionData {
-    CompiledData::CompilationUnitBase *compilationUnit;
+struct Q_QML_EXPORT FunctionData
+{
+    WriteBarrier::HeapObjectWrapper<CompilationUnitRuntimeData, 1> compilationUnit;
 
     // Intentionally require an ExecutableCompilationUnit but save only a pointer to
     // CompilationUnitBase. This is so that we can take advantage of the standard layout
     // of CompilationUnitBase in the JIT. Furthermore we can safely static_cast to
     // ExecutableCompilationUnit where we need it.
-    FunctionData(ExecutableCompilationUnit *compilationUnit)
-        : compilationUnit(compilationUnit)
-    {}
+    FunctionData(EngineBase *engine, ExecutableCompilationUnit *compilationUnit_);
 };
 // Make sure this class can be accessed through offsetof (done by the assemblers):
 Q_STATIC_ASSERT(std::is_standard_layout< FunctionData >::value);
@@ -47,16 +46,22 @@ Q_STATIC_ASSERT(std::is_standard_layout< FunctionData >::value);
 struct Q_QML_EXPORT Function : public FunctionData {
 protected:
     Function(ExecutionEngine *engine, ExecutableCompilationUnit *unit,
-             const CompiledData::Function *function, const QQmlPrivate::TypedFunction *aotFunction);
+             const CompiledData::Function *function, const QQmlPrivate::AOTCompiledFunction *aotFunction);
     ~Function();
 
 public:
-    const CompiledData::Function *compiledFunction;
+    struct JSTypedFunction {
+        QVarLengthArray<QQmlType, 4> types;
+    };
+
+    struct AOTCompiledFunction {
+        QVarLengthArray<QMetaType, 4> types;
+    };
 
     QV4::ExecutableCompilationUnit *executableCompilationUnit() const
     {
         // This is safe: We require an ExecutableCompilationUnit in the ctor.
-        return static_cast<QV4::ExecutableCompilationUnit *>(compilationUnit);
+        return static_cast<QV4::ExecutableCompilationUnit *>(compilationUnit.get());
     }
 
     QV4::Heap::String *runtimeString(uint i) const
@@ -69,26 +74,39 @@ public:
     ReturnedValue call(const Value *thisObject, const Value *argv, int argc,
                        ExecutionContext *context);
 
-    const char *codeData;
+    const CompiledData::Function *compiledFunction = nullptr;
+    const char *codeData = nullptr;
+    JSC::MacroAssemblerCodeRef *codeRef = nullptr;
 
     typedef ReturnedValue (*JittedCode)(CppStackFrame *, ExecutionEngine *);
-    JittedCode jittedCode;
-    JSC::MacroAssemblerCodeRef *codeRef;
-    const QQmlPrivate::TypedFunction *typedFunction = nullptr;
+    typedef void (*AotCompiledCode)(const QQmlPrivate::AOTCompiledContext *context, void **argv);
+
+    union {
+        void *noFunction = nullptr;
+        JSTypedFunction jsTypedFunction;
+        AOTCompiledFunction aotCompiledFunction;
+    };
+
+    union {
+        JittedCode jittedCode = nullptr;
+        AotCompiledCode aotCompiledCode;
+    };
 
     // first nArguments names in internalClass are the actual arguments
-    Heap::InternalClass *internalClass;
+    QV4::WriteBarrier::Pointer<Heap::InternalClass> internalClass;
     int interpreterCallCount = 0;
-    quint16 nFormals;
+    quint16 nFormals = 0;
     enum Kind : quint8 { JsUntyped, JsTyped, AotCompiled, Eval };
     Kind kind = JsUntyped;
     bool detectedInjectedParameters = false;
 
     static Function *create(ExecutionEngine *engine, ExecutableCompilationUnit *unit,
                             const CompiledData::Function *function,
-                            const QQmlPrivate::TypedFunction *aotFunction);
+                            const QQmlPrivate::AOTCompiledFunction *aotFunction);
     void destroy();
 
+    void mark(QV4::MarkStack *ms);
+
     // used when dynamically assigning signal handlers (QQmlConnection)
     void updateInternalClass(ExecutionEngine *engine, const QList<QByteArray> &parameters);