Save some stack space during code generation

Result objects are rather large, 96 bytes here. In a recursive algorithm
such as our parser, we should not keep too many of them on the stack.
Also, the size of Reference can be reduced by employing a bit field
rather than a number of booleans.

Also, try to convince the compiler to inline the accept() functions. The
extra stack frames those create are unnecessary.

Task-number: QTBUG-74087
Change-Id: I5c064491172366bb0abef99ffe9314080401a7d1
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

3 files changed, 176 insertions, 135 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index 2421e8c1ea..59b9968bf6 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -566,7 +566,7 @@ bool IRBuilder::visit(QQmlJS::AST::UiQualifiedId *id)
 
 void IRBuilder::accept(QQmlJS::AST::Node *node)
 {
-    QQmlJS::AST::Node::acceptChild(node, this);
+    QQmlJS::AST::Node::accept(node, this);
 }
 
 bool IRBuilder::defineQMLObject(int *objectIndex, QQmlJS::AST::UiQualifiedId *qualifiedTypeNameId, const QQmlJS::AST::SourceLocation &location, QQmlJS::AST::UiObjectInitializer *initializer, Object *declarationsOverride)
diff --git a/src/qml/compiler/qv4codegen.cpp b/src/qml/compiler/qv4codegen.cpp
index 256ab6e0be..b4da05eb9a 100644
--- a/src/qml/compiler/qv4codegen.cpp
+++ b/src/qml/compiler/qv4codegen.cpp
@@ -100,6 +100,7 @@ Codegen::Codegen(QV4::Compiler::JSUnitGenerator *jsUnitGenerator, bool strict)
     , hasError(false)
 {
     jsUnitGenerator->codeGeneratorName = QStringLiteral("moth");
+    pushExpr();
 }
 
 const char *globalNames[] = {
@@ -264,7 +265,7 @@ Context *Codegen::enterBlock(Node *node)
 Codegen::Reference Codegen::unop(UnaryOperation op, const Reference &expr)
 {
     if (hasError)
-        return _expr.result();
+        return exprResult();
 
     if (expr.isConstant()) {
         auto v = Value::fromReturnedValue(expr.constant);
@@ -310,7 +311,7 @@ Codegen::Reference Codegen::unop(UnaryOperation op, const Reference &expr)
         return Reference::fromAccumulator(this);
     }
     case PostIncrement:
-        if (!_expr.accept(nx) || requiresReturnValue) {
+        if (!exprAccept(nx) || requiresReturnValue) {
             Reference e = expr.asLValue();
             e.loadInAccumulator();
             Instruction::UPlus uplus;
@@ -330,13 +331,13 @@ Codegen::Reference Codegen::unop(UnaryOperation op, const Reference &expr)
         e.loadInAccumulator();
         Instruction::Increment inc;
         bytecodeGenerator->addInstruction(inc);
-        if (_expr.accept(nx))
+        if (exprAccept(nx))
             return e.storeConsumeAccumulator();
         else
             return e.storeRetainAccumulator();
     }
     case PostDecrement:
-        if (!_expr.accept(nx) || requiresReturnValue) {
+        if (!exprAccept(nx) || requiresReturnValue) {
             Reference e = expr.asLValue();
             e.loadInAccumulator();
             Instruction::UPlus uplus;
@@ -356,7 +357,7 @@ Codegen::Reference Codegen::unop(UnaryOperation op, const Reference &expr)
         e.loadInAccumulator();
         Instruction::Decrement dec;
         bytecodeGenerator->addInstruction(dec);
-        if (_expr.accept(nx))
+        if (exprAccept(nx))
             return e.storeConsumeAccumulator();
         else
             return e.storeRetainAccumulator();
@@ -368,17 +369,9 @@ Codegen::Reference Codegen::unop(UnaryOperation op, const Reference &expr)
 
 void Codegen::addCJump()
 {
-    bytecodeGenerator->addCJumpInstruction(_expr.trueBlockFollowsCondition(),
-                                           _expr.iftrue(), _expr.iffalse());
-}
-
-void Codegen::accept(Node *node)
-{
-    if (hasError)
-        return;
-
-    if (node)
-        node->accept(this);
+    const Result &expression = currentExpr();
+    bytecodeGenerator->addCJumpInstruction(expression.trueBlockFollowsCondition(),
+                                           expression.iftrue(), expression.iffalse());
 }
 
 void Codegen::statement(Statement *ast)
@@ -402,20 +395,19 @@ void Codegen::statement(ExpressionNode *ast)
         RecursionDepthCheck depthCheck(this, ast->lastSourceLocation());
         RegisterScope scope(this);
 
-        Result r(nx);
-        qSwap(_expr, r);
+        pushExpr(Result(nx));
         VolatileMemoryLocations vLocs = scanVolatileMemoryLocations(ast);
         qSwap(_volatileMemoryLocations, vLocs);
 
         accept(ast);
 
         qSwap(_volatileMemoryLocations, vLocs);
-        qSwap(_expr, r);
+        Reference result = popResult();
 
         if (hasError)
             return;
-        if (r.result().loadTriggersSideEffect())
-            r.result().loadInAccumulator(); // triggers side effects
+        if (result.loadTriggersSideEffect())
+            result.loadInAccumulator(); // triggers side effects
     }
 }
 
@@ -429,10 +421,9 @@ void Codegen::condition(ExpressionNode *ast, const BytecodeGenerator::Label *ift
         return;
 
     RecursionDepthCheck depthCheck(this, ast->lastSourceLocation());
-    Result r(iftrue, iffalse, trueBlockFollowsCondition);
-    qSwap(_expr, r);
+    pushExpr(Result(iftrue, iffalse, trueBlockFollowsCondition));
     accept(ast);
-    qSwap(_expr, r);
+    Result r = popExpr();
 
     if (hasError)
         return;
@@ -450,18 +441,6 @@ void Codegen::condition(ExpressionNode *ast, const BytecodeGenerator::Label *ift
     }
 }
 
-Codegen::Reference Codegen::expression(ExpressionNode *ast)
-{
-    RecursionDepthCheck depthCheck(this, ast->lastSourceLocation());
-    Result r;
-    if (ast) {
-        qSwap(_expr, r);
-        accept(ast);
-        qSwap(_expr, r);
-    }
-    return r.result();
-}
-
 void Codegen::program(Program *ast)
 {
     if (ast) {
@@ -875,17 +854,13 @@ bool Codegen::visit(ExportDeclaration *ast)
     Reference exportedValue;
 
     if (auto *fdecl = AST::cast<FunctionDeclaration*>(ast->variableStatementOrDeclaration)) {
-        Result r;
-        qSwap(_expr, r);
+        pushExpr();
         visit(static_cast<FunctionExpression*>(fdecl));
-        qSwap(_expr, r);
-        exportedValue = r.result();
+        exportedValue = popResult();
     } else if (auto *classDecl = AST::cast<ClassDeclaration*>(ast->variableStatementOrDeclaration)) {
-        Result r;
-        qSwap(_expr, r);
+        pushExpr();
         visit(static_cast<ClassExpression*>(classDecl));
-        qSwap(_expr, r);
-        exportedValue = r.result();
+        exportedValue = popResult();
     } else if (ExpressionNode *expr = ast->variableStatementOrDeclaration->expressionCast()) {
         exportedValue = expression(expr);
     }
@@ -1068,7 +1043,7 @@ bool Codegen::visit(ClassExpression *ast)
         (void) ctor.storeRetainAccumulator();
     }
 
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
     return false;
 }
 
@@ -1151,7 +1126,7 @@ bool Codegen::visit(ArrayPattern *ast)
     }
 
     if (!it) {
-        _expr.setResult(Reference::fromAccumulator(this));
+        setExprResult(Reference::fromAccumulator(this));
         return false;
     }
     Q_ASSERT(it->element && it->element->type == PatternElement::SpreadElement);
@@ -1245,7 +1220,7 @@ bool Codegen::visit(ArrayPattern *ast)
     }
 
     array.loadInAccumulator();
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
 
     return false;
 }
@@ -1261,7 +1236,7 @@ bool Codegen::visit(ArrayMemberExpression *ast)
         return false;
     if (base.isSuper()) {
         Reference index = expression(ast->expression).storeOnStack();
-        _expr.setResult(Reference::fromSuperProperty(index));
+        setExprResult(Reference::fromSuperProperty(index));
         return false;
     }
     base = base.storeOnStack();
@@ -1271,17 +1246,17 @@ bool Codegen::visit(ArrayMemberExpression *ast)
         QString s = str->value.toString();
         uint arrayIndex = QV4::String::toArrayIndex(s);
         if (arrayIndex == UINT_MAX) {
-            _expr.setResult(Reference::fromMember(base, str->value.toString()));
+            setExprResult(Reference::fromMember(base, str->value.toString()));
             return false;
         }
         Reference index = Reference::fromConst(this, QV4::Encode(arrayIndex));
-        _expr.setResult(Reference::fromSubscript(base, index));
+        setExprResult(Reference::fromSubscript(base, index));
         return false;
     }
     Reference index = expression(ast->expression);
     if (hasError)
         return false;
-    _expr.setResult(Reference::fromSubscript(base, index));
+    setExprResult(Reference::fromSubscript(base, index));
     return false;
 }
 
@@ -1312,12 +1287,13 @@ bool Codegen::visit(BinaryExpression *ast)
     TailCallBlocker blockTailCalls(this);
 
     if (ast->op == QSOperator::And) {
-        if (_expr.accept(cx)) {
+        if (exprAccept(cx)) {
             auto iftrue = bytecodeGenerator->newLabel();
-            condition(ast->left, &iftrue, _expr.iffalse(), true);
+            condition(ast->left, &iftrue, currentExpr().iffalse(), true);
             iftrue.link();
             blockTailCalls.unblock();
-            condition(ast->right, _expr.iftrue(), _expr.iffalse(), _expr.trueBlockFollowsCondition());
+            const Result &expr = currentExpr();
+            condition(ast->right, expr.iftrue(), expr.iffalse(), expr.trueBlockFollowsCondition());
         } else {
             auto iftrue = bytecodeGenerator->newLabel();
             auto endif = bytecodeGenerator->newLabel();
@@ -1339,15 +1315,16 @@ bool Codegen::visit(BinaryExpression *ast)
 
             endif.link();
 
-            _expr.setResult(Reference::fromAccumulator(this));
+            setExprResult(Reference::fromAccumulator(this));
         }
         return false;
     } else if (ast->op == QSOperator::Or) {
-        if (_expr.accept(cx)) {
+        if (exprAccept(cx)) {
             auto iffalse = bytecodeGenerator->newLabel();
-            condition(ast->left, _expr.iftrue(), &iffalse, false);
+            condition(ast->left, currentExpr().iftrue(), &iffalse, false);
             iffalse.link();
-            condition(ast->right, _expr.iftrue(), _expr.iffalse(), _expr.trueBlockFollowsCondition());
+            const Result &expr = currentExpr();
+            condition(ast->right, expr.iftrue(), expr.iffalse(), expr.trueBlockFollowsCondition());
         } else {
             auto iffalse = bytecodeGenerator->newLabel();
             auto endif = bytecodeGenerator->newLabel();
@@ -1369,7 +1346,7 @@ bool Codegen::visit(BinaryExpression *ast)
 
             endif.link();
 
-            _expr.setResult(Reference::fromAccumulator(this));
+            setExprResult(Reference::fromAccumulator(this));
         }
         return false;
     } else if (ast->op == QSOperator::Assign) {
@@ -1380,9 +1357,9 @@ bool Codegen::visit(BinaryExpression *ast)
                 return false;
             right = right.storeOnStack();
             destructurePattern(p, right);
-            if (!_expr.accept(nx)) {
+            if (!exprAccept(nx)) {
                 right.loadInAccumulator();
-                _expr.setResult(Reference::fromAccumulator(this));
+                setExprResult(Reference::fromAccumulator(this));
             }
             return false;
         }
@@ -1402,10 +1379,10 @@ bool Codegen::visit(BinaryExpression *ast)
         if (hasError)
             return false;
         r.loadInAccumulator();
-        if (_expr.accept(nx))
-            _expr.setResult(left.storeConsumeAccumulator());
+        if (exprAccept(nx))
+            setExprResult(left.storeConsumeAccumulator());
         else
-            _expr.setResult(left.storeRetainAccumulator());
+            setExprResult(left.storeRetainAccumulator());
         return false;
     }
 
@@ -1448,7 +1425,7 @@ bool Codegen::visit(BinaryExpression *ast)
             return false;
 
         binopHelper(baseOp(ast->op), tempLeft, right).loadInAccumulator();
-        _expr.setResult(left.storeRetainAccumulator());
+        setExprResult(left.storeRetainAccumulator());
 
         break;
     }
@@ -1460,7 +1437,7 @@ bool Codegen::visit(BinaryExpression *ast)
             Reference right = expression(ast->right);
             if (hasError)
                 return false;
-            _expr.setResult(binopHelper(static_cast<QSOperator::Op>(ast->op), right, left));
+            setExprResult(binopHelper(static_cast<QSOperator::Op>(ast->op), right, left));
             break;
         }
         // intentional fall-through!
@@ -1486,7 +1463,7 @@ bool Codegen::visit(BinaryExpression *ast)
         Reference right;
         if (AST::NumericLiteral *rhs = AST::cast<AST::NumericLiteral *>(ast->right)) {
             visit(rhs);
-            right = _expr.result();
+            right = exprResult();
         } else {
             left = left.storeOnStack(); // force any loads of the lhs, so the rhs won't clobber it
             right = expression(ast->right);
@@ -1494,7 +1471,7 @@ bool Codegen::visit(BinaryExpression *ast)
         if (hasError)
             return false;
 
-        _expr.setResult(binopHelper(static_cast<QSOperator::Op>(ast->op), left, right));
+        setExprResult(binopHelper(static_cast<QSOperator::Op>(ast->op), left, right));
 
         break;
     }
@@ -1671,7 +1648,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::StrictEqual: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpStrictEqual cmp;
@@ -1682,7 +1659,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::StrictNotEqual: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpStrictNotEqual cmp;
@@ -1693,7 +1670,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::Equal: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpEq cmp;
@@ -1704,7 +1681,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::NotEqual: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpNe cmp;
@@ -1715,7 +1692,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::Gt: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpGt cmp;
@@ -1726,7 +1703,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::Ge: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpGe cmp;
@@ -1737,7 +1714,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::Lt: {
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpLt cmp;
@@ -1748,7 +1725,7 @@ Codegen::Reference Codegen::binopHelper(QSOperator::Op oper, Reference &left, Re
         break;
     }
     case QSOperator::Le:
-        if (_expr.accept(cx))
+        if (exprAccept(cx))
             return jumpBinop(oper, left, right);
 
         Instruction::CmpLe cmp;
@@ -1952,7 +1929,7 @@ bool Codegen::visit(CallExpression *ast)
             bytecodeGenerator->addInstruction(call);
         }
 
-        _expr.setResult(Reference::fromAccumulator(this));
+        setExprResult(Reference::fromAccumulator(this));
         return false;
 
     }
@@ -2045,7 +2022,7 @@ void Codegen::handleCall(Reference &base, Arguments calldata, int slotForFunctio
         bytecodeGenerator->addInstruction(call);
     }
 
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
 }
 
 Codegen::Arguments Codegen::pushArgs(ArgumentList *args)
@@ -2141,7 +2118,7 @@ bool Codegen::visit(ConditionalExpression *ast)
     ko.loadInAccumulator();
 
     jump_endif.link();
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
 
     return false;
 }
@@ -2171,7 +2148,7 @@ bool Codegen::visit(DeleteExpression *ast)
             throwSyntaxError(ast->deleteToken, QStringLiteral("Delete of an unqualified identifier in strict mode."));
             return false;
         }
-        _expr.setResult(Reference::fromConst(this, QV4::Encode(false)));
+        setExprResult(Reference::fromConst(this, QV4::Encode(false)));
         return false;
     case Reference::Name: {
         if (_context->isStrict) {
@@ -2181,7 +2158,7 @@ bool Codegen::visit(DeleteExpression *ast)
         Instruction::DeleteName del;
         del.name = expr.nameAsIndex();
         bytecodeGenerator->addInstruction(del);
-        _expr.setResult(Reference::fromAccumulator(this));
+        setExprResult(Reference::fromAccumulator(this));
         return false;
     }
     case Reference::Member: {
@@ -2196,7 +2173,7 @@ bool Codegen::visit(DeleteExpression *ast)
         del.base = expr.propertyBase.stackSlot();
         del.index = index.stackSlot();
         bytecodeGenerator->addInstruction(del);
-        _expr.setResult(Reference::fromAccumulator(this));
+        setExprResult(Reference::fromAccumulator(this));
         return false;
     }
     case Reference::Subscript: {
@@ -2206,14 +2183,14 @@ bool Codegen::visit(DeleteExpression *ast)
         del.base = expr.elementBase;
         del.index = expr.elementSubscript.stackSlot();
         bytecodeGenerator->addInstruction(del);
-        _expr.setResult(Reference::fromAccumulator(this));
+        setExprResult(Reference::fromAccumulator(this));
         return false;
     }
     default:
         break;
     }
     // [[11.4.1]] Return true if it's not a reference
-    _expr.setResult(Reference::fromConst(this, QV4::Encode(true)));
+    setExprResult(Reference::fromConst(this, QV4::Encode(true)));
     return false;
 }
 
@@ -2222,7 +2199,7 @@ bool Codegen::visit(FalseLiteral *)
     if (hasError)
         return false;
 
-    _expr.setResult(Reference::fromConst(this, QV4::Encode(false)));
+    setExprResult(Reference::fromConst(this, QV4::Encode(false)));
     return false;
 }
 
@@ -2231,7 +2208,7 @@ bool Codegen::visit(SuperLiteral *)
     if (hasError)
         return false;
 
-    _expr.setResult(Reference::fromSuper(this));
+    setExprResult(Reference::fromSuper(this));
     return false;
 }
 
@@ -2249,12 +2226,12 @@ bool Codegen::visit(FieldMemberExpression *ast)
             if (_context->isArrowFunction || _context->contextType == ContextType::Eval) {
                 Reference r = referenceForName(QStringLiteral("new.target"), false);
                 r.isReadonly = true;
-                _expr.setResult(r);
+                setExprResult(r);
                 return false;
             }
 
             Reference r = Reference::fromStackSlot(this, CallData::NewTarget);
-            _expr.setResult(r);
+            setExprResult(r);
             return false;
         }
     }
@@ -2267,10 +2244,10 @@ bool Codegen::visit(FieldMemberExpression *ast)
         load.stringId = registerString(ast->name.toString());
         bytecodeGenerator->addInstruction(load);
         Reference property = Reference::fromAccumulator(this).storeOnStack();
-        _expr.setResult(Reference::fromSuperProperty(property));
+        setExprResult(Reference::fromSuperProperty(property));
         return false;
     }
-    _expr.setResult(Reference::fromMember(base, ast->name.toString()));
+    setExprResult(Reference::fromMember(base, ast->name.toString()));
     return false;
 }
 
@@ -2280,12 +2257,15 @@ bool Codegen::visit(TaggedTemplate *ast)
         return false;
 
     RegisterScope scope(this);
+    return handleTaggedTemplate(expression(ast->base), ast);
+}
 
-    int functionObject = -1, thisObject = -1;
-
-    Reference base = expression(ast->base);
+bool Codegen::handleTaggedTemplate(Reference base, TaggedTemplate *ast)
+{
     if (hasError)
         return false;
+
+    int functionObject = -1, thisObject = -1;
     switch (base.type) {
     case Reference::Member:
     case Reference::Subscript:
@@ -2346,7 +2326,7 @@ bool Codegen::visit(FunctionExpression *ast)
     if (hasError)
         return false;
     loadClosure(function);
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
     return false;
 }
 
@@ -2412,7 +2392,7 @@ bool Codegen::visit(IdentifierExpression *ast)
     if (hasError)
         return false;
 
-    _expr.setResult(referenceForName(ast->name.toString(), false, ast->firstSourceLocation()));
+    setExprResult(referenceForName(ast->name.toString(), false, ast->firstSourceLocation()));
     return false;
 }
 
@@ -2462,7 +2442,7 @@ void Codegen::handleConstruct(const Reference &base, ArgumentList *arguments)
         // set the result up as the thisObject
         Reference::fromAccumulator(this).storeOnStack(CallData::This);
 
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
 }
 
 bool Codegen::visit(NewExpression *ast)
@@ -2511,7 +2491,7 @@ bool Codegen::visit(NotExpression *ast)
         return false;
 
     TailCallBlocker blockTailCalls(this);
-    _expr.setResult(unop(Not, expression(ast->expression)));
+    setExprResult(unop(Not, expression(ast->expression)));
     return false;
 }
 
@@ -2520,10 +2500,10 @@ bool Codegen::visit(NullExpression *)
     if (hasError)
         return false;
 
-    if (_expr.accept(cx))
-        bytecodeGenerator->jump().link(*_expr.iffalse());
+    if (exprAccept(cx))
+        bytecodeGenerator->jump().link(*currentExpr().iffalse());
     else
-        _expr.setResult(Reference::fromConst(this, Encode::null()));
+        setExprResult(Reference::fromConst(this, Encode::null()));
 
     return false;
 }
@@ -2533,7 +2513,7 @@ bool Codegen::visit(NumericLiteral *ast)
     if (hasError)
         return false;
 
-    _expr.setResult(Reference::fromConst(this, QV4::Encode::smallestNumber(ast->value)));
+    setExprResult(Reference::fromConst(this, QV4::Encode::smallestNumber(ast->value)));
     return false;
 }
 
@@ -2648,8 +2628,7 @@ bool Codegen::visit(ObjectPattern *ast)
     call.argc = argc;
     call.args = Moth::StackSlot::createRegister(args);
     bytecodeGenerator->addInstruction(call);
-    Reference result = Reference::fromAccumulator(this);
-    _expr.setResult(result);
+    setExprResult(Reference::fromAccumulator(this));
     return false;
 }
 
@@ -2668,7 +2647,7 @@ bool Codegen::visit(PostDecrementExpression *ast)
     if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(expr, ast->decrementToken))
         return false;
 
-    _expr.setResult(unop(PostDecrement, expr));
+    setExprResult(unop(PostDecrement, expr));
 
     return false;
 }
@@ -2688,7 +2667,7 @@ bool Codegen::visit(PostIncrementExpression *ast)
     if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(expr, ast->incrementToken))
         return false;
 
-    _expr.setResult(unop(PostIncrement, expr));
+    setExprResult(unop(PostIncrement, expr));
     return false;
 }
 
@@ -2706,7 +2685,7 @@ bool Codegen::visit(PreDecrementExpression *ast)
 
     if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(expr, ast->decrementToken))
         return false;
-    _expr.setResult(unop(PreDecrement, expr));
+    setExprResult(unop(PreDecrement, expr));
     return false;
 }
 
@@ -2725,7 +2704,7 @@ bool Codegen::visit(PreIncrementExpression *ast)
 
     if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(expr, ast->incrementToken))
         return false;
-    _expr.setResult(unop(PreIncrement, expr));
+    setExprResult(unop(PreIncrement, expr));
     return false;
 }
 
@@ -2736,7 +2715,7 @@ bool Codegen::visit(RegExpLiteral *ast)
 
     auto r = Reference::fromStackSlot(this);
     r.isReadonly = true;
-    _expr.setResult(r);
+    setExprResult(r);
 
     Instruction::MoveRegExp instr;
     instr.regExpId = jsUnitGenerator->registerRegExp(ast);
@@ -2752,7 +2731,7 @@ bool Codegen::visit(StringLiteral *ast)
 
     auto r = Reference::fromAccumulator(this);
     r.isReadonly = true;
-    _expr.setResult(r);
+    setExprResult(r);
 
     Instruction::LoadRuntimeString instr;
     instr.stringId = registerString(ast->value.toString());
@@ -2802,7 +2781,7 @@ bool Codegen::visit(TemplateLiteral *ast)
     auto r = Reference::fromAccumulator(this);
     r.isReadonly = true;
 
-    _expr.setResult(r);
+    setExprResult(r);
     return false;
 
 }
@@ -2815,10 +2794,10 @@ bool Codegen::visit(ThisExpression *)
     if (_context->isArrowFunction) {
         Reference r = referenceForName(QStringLiteral("this"), false);
         r.isReadonly = true;
-        _expr.setResult(r);
+        setExprResult(r);
         return false;
     }
-    _expr.setResult(Reference::fromThis(this));
+    setExprResult(Reference::fromThis(this));
     return false;
 }
 
@@ -2828,7 +2807,7 @@ bool Codegen::visit(TildeExpression *ast)
         return false;
 
     TailCallBlocker blockTailCalls(this);
-    _expr.setResult(unop(Compl, expression(ast->expression)));
+    setExprResult(unop(Compl, expression(ast->expression)));
     return false;
 }
 
@@ -2837,7 +2816,7 @@ bool Codegen::visit(TrueLiteral *)
     if (hasError)
         return false;
 
-    _expr.setResult(Reference::fromConst(this, QV4::Encode(true)));
+    setExprResult(Reference::fromConst(this, QV4::Encode(true)));
     return false;
 }
 
@@ -2863,7 +2842,7 @@ bool Codegen::visit(TypeOfExpression *ast)
         Instruction::TypeofValue instr;
         bytecodeGenerator->addInstruction(instr);
     }
-    _expr.setResult(Reference::fromAccumulator(this));
+    setExprResult(Reference::fromAccumulator(this));
 
     return false;
 }
@@ -2874,7 +2853,7 @@ bool Codegen::visit(UnaryMinusExpression *ast)
         return false;
 
     TailCallBlocker blockTailCalls(this);
-    _expr.setResult(unop(UMinus, expression(ast->expression)));
+    setExprResult(unop(UMinus, expression(ast->expression)));
     return false;
 }
 
@@ -2884,7 +2863,7 @@ bool Codegen::visit(UnaryPlusExpression *ast)
         return false;
 
     TailCallBlocker blockTailCalls(this);
-    _expr.setResult(unop(UPlus, expression(ast->expression)));
+    setExprResult(unop(UPlus, expression(ast->expression)));
     return false;
 }
 
@@ -2897,7 +2876,7 @@ bool Codegen::visit(VoidExpression *ast)
     TailCallBlocker blockTailCalls(this);
 
     statement(ast->expression);
-    _expr.setResult(Reference::fromConst(this, Encode::undefined()));
+    setExprResult(Reference::fromConst(this, Encode::undefined()));
     return false;
 }
 
@@ -2911,7 +2890,7 @@ bool Codegen::visit(FunctionDeclaration * ast)
 
     if (_functionContext->contextType == ContextType::Binding)
         referenceForName(ast->name.toString(), true).loadInAccumulator();
-    _expr.accept(nx);
+    exprAccept(nx);
     return false;
 }
 
@@ -2967,7 +2946,7 @@ bool Codegen::visit(YieldExpression *ast)
         done.link();
 
         lhsValue.loadInAccumulator();
-        _expr.setResult(acc);
+        setExprResult(acc);
         return false;
     }
 
@@ -2978,7 +2957,7 @@ bool Codegen::visit(YieldExpression *ast)
     BytecodeGenerator::Jump jump = bytecodeGenerator->addJumpInstruction(resume);
     emitReturn(acc);
     jump.link();
-    _expr.setResult(acc);
+    setExprResult(acc);
     return false;
 }
 
diff --git a/src/qml/compiler/qv4codegen_p.h b/src/qml/compiler/qv4codegen_p.h
index 4d7001fe64..c1063bc0d0 100644
--- a/src/qml/compiler/qv4codegen_p.h
+++ b/src/qml/compiler/qv4codegen_p.h
@@ -192,8 +192,24 @@ public:
 
         bool isLValue() const { return !isReadonly && type > Accumulator; }
 
-        Reference(Codegen *cg, Type type = Invalid) : type(type), constant(0), codegen(cg) {}
-        Reference(): constant(0) {}
+        Reference(Codegen *cg, Type t = Invalid) : Reference()
+        {
+            type = t;
+            codegen = cg;
+        }
+
+        Reference() :
+            constant(0),
+            isArgOrEval(false),
+            isReadonly(false),
+            isReferenceToConst(false),
+            requiresTDZCheck(false),
+            subscriptRequiresTDZCheck(false),
+            stackSlotIsLocalOrArgument(false),
+            isVolatile(false),
+            global(false)
+        {}
+
         Reference(const Reference &) = default;
         Reference(Reference &&) = default;
         Reference &operator =(const Reference &) = default;
@@ -395,16 +411,17 @@ public:
             Moth::StackSlot property; // super property
         };
         QString name;
-        mutable bool isArgOrEval = false;
-        bool isReadonly = false;
-        bool isReferenceToConst = false;
-        bool requiresTDZCheck = false;
-        bool subscriptRequiresTDZCheck = false;
-        bool stackSlotIsLocalOrArgument = false;
-        bool isVolatile = false;
-        bool global = false;
         Codegen *codegen = nullptr;
 
+        quint32 isArgOrEval:1;
+        quint32 isReadonly:1;
+        quint32 isReferenceToConst:1;
+        quint32 requiresTDZCheck:1;
+        quint32 subscriptRequiresTDZCheck:1;
+        quint32 stackSlotIsLocalOrArgument:1;
+        quint32 isVolatile:1;
+        quint32 global:1;
+
     private:
         void storeAccumulator() const;
         Reference doStoreOnStack(int tempIndex) const;
@@ -499,6 +516,10 @@ protected:
         void setResult(const Reference &result) {
             _result = result;
         }
+
+        void setResult(Reference &&result) {
+            _result = std::move(result);
+        }
     };
 
     void enterContext(AST::Node *node);
@@ -544,9 +565,23 @@ protected:
     void condition(AST::ExpressionNode *ast, const BytecodeGenerator::Label *iftrue,
                    const BytecodeGenerator::Label *iffalse,
                    bool trueBlockFollowsCondition);
-    Reference expression(AST::ExpressionNode *ast);
 
-    void accept(AST::Node *node);
+    inline Reference expression(AST::ExpressionNode *ast)
+    {
+        if (!ast || hasError)
+            return Reference();
+
+        RecursionDepthCheck depthCheck(this, ast->lastSourceLocation());
+        pushExpr();
+        ast->accept(this);
+        return popResult();
+    }
+
+    inline void accept(AST::Node *node)
+    {
+        if (!hasError && node)
+            node->accept(this);
+    }
 
     void program(AST::Program *ast);
     void statementList(AST::StatementList *ast);
@@ -684,6 +719,7 @@ public:
     void handleCall(Reference &base, Arguments calldata, int slotForFunction, int slotForThisObject);
 
     Arguments pushTemplateArgs(AST::TemplateLiteral *args);
+    bool handleTaggedTemplate(Reference base, AST::TaggedTemplate *ast);
     void createTemplateObject(AST::TemplateLiteral *t);
 
     void setUseFastLookups(bool b) { useFastLookups = b; }
@@ -720,7 +756,33 @@ protected:
     friend struct ControlFlow;
     friend struct ControlFlowCatch;
     friend struct ControlFlowFinally;
-    Result _expr;
+
+    inline void setExprResult(const Reference &result) { m_expressions.back().setResult(result); }
+    inline void setExprResult(Reference &&result) { m_expressions.back().setResult(std::move(result)); }
+    inline Reference exprResult() const { return m_expressions.back().result(); }
+
+    inline bool exprAccept(Format f) { return m_expressions.back().accept(f); }
+
+    inline const Result &currentExpr() const { return m_expressions.back(); }
+
+    inline void pushExpr(Result &&expr) { m_expressions.push_back(std::move(expr)); }
+    inline void pushExpr(const Result &expr) { m_expressions.push_back(expr); }
+    inline void pushExpr() { m_expressions.emplace_back(); }
+
+    inline Result popExpr()
+    {
+        const Result result = m_expressions.back();
+        m_expressions.pop_back();
+        return result;
+    }
+
+    inline Reference popResult() {
+        const Reference result = m_expressions.back().result();
+        m_expressions.pop_back();
+        return result;
+    }
+
+    std::vector<Result> m_expressions;
     VolatileMemoryLocations _volatileMemoryLocations;
     Module *_module;
     int _returnAddress;