Don't call alloca(0)

Apparently that's not a good idea.

Change-Id: Ic49f6d40135f65e39725acd7a745d17917b64be3
Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

1 files changed, 28 insertions, 13 deletions

diff --git a/src/qml/jsruntime/qv4vme_moth.cpp b/src/qml/jsruntime/qv4vme_moth.cpp
index ebc018a595..581282c316 100644
--- a/src/qml/jsruntime/qv4vme_moth.cpp
+++ b/src/qml/jsruntime/qv4vme_moth.cpp
@@ -462,20 +462,31 @@ ReturnedValue VME::exec(CppStackFrame *frame, ExecutionEngine *engine)
         result = function->jittedCode(frame, engine);
     } else if (function->aotFunction) {
         const qsizetype numFunctionArguments = function->aotFunction->argumentTypes.size();
-        Q_ALLOCA_VAR(void *, argumentPtrs, numFunctionArguments * sizeof(void *));
-
-        for (qsizetype i = 0; i < numFunctionArguments; ++i) {
-            const QMetaType argumentType = function->aotFunction->argumentTypes[i];
-            Q_ALLOCA_VAR(void, argument, argumentType.sizeOf());
-            if (i < frame->originalArgumentsCount)
-                engine->metaTypeFromJS(frame->originalArguments[i], argumentType.id(), argument);
-            else
-                argumentType.construct(argument);
-            argumentPtrs[i] = argument;
+        Q_ALLOCA_DECLARE(void *, argumentPtrs);
+
+        if (numFunctionArguments > 0) {
+            Q_ALLOCA_ASSIGN(void *, argumentPtrs, numFunctionArguments * sizeof(void *));
+            for (qsizetype i = 0; i < numFunctionArguments; ++i) {
+                const QMetaType argumentType = function->aotFunction->argumentTypes[i];
+                if (const qsizetype argumentSize = argumentType.sizeOf()) {
+                    Q_ALLOCA_VAR(void, argument, argumentSize);
+                    if (i < frame->originalArgumentsCount) {
+                        engine->metaTypeFromJS(frame->originalArguments[i], argumentType.id(),
+                                               argument);
+                    } else {
+                        argumentType.construct(argument);
+                    }
+                    argumentPtrs[i] = argument;
+                } else {
+                    argumentPtrs[i] = nullptr;
+                }
+            }
         }
 
+        Q_ALLOCA_DECLARE(void, returnValue);
         const QMetaType returnType = function->aotFunction->returnType;
-        Q_ALLOCA_VAR(void, returnValue, returnType.sizeOf());
+        if (const qsizetype returnSize = returnType.sizeOf())
+            Q_ALLOCA_ASSIGN(void, returnValue, returnSize);
 
         Scope scope(engine);
         Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
@@ -483,9 +494,13 @@ ReturnedValue VME::exec(CppStackFrame *frame, ExecutionEngine *engine)
                 qmlContext->qmlContext()->asQQmlContext(), qmlContext->qmlScope(),
                 returnValue, const_cast<const void **>(argumentPtrs)); // We're adding const here
 
-        result = engine->metaTypeToJS(returnType.id(), returnValue);
+        if (returnValue) {
+            result = engine->metaTypeToJS(returnType.id(), returnValue);
+            returnType.destruct(returnValue);
+        } else {
+            result = Encode::undefined();
+        }
 
-        returnType.destruct(returnValue);
         for (qsizetype i = 0; i < numFunctionArguments; ++i)
             function->aotFunction->argumentTypes[i].destruct(argumentPtrs[i]);
     } else {