Allow more copy elision on return statements

Author: limepoutine

compiler/src/dmd/glue/e2ir.d

@@ -754,7 +754,7 @@ elem* toElem(Expression e, ref IRState irs)
             }
         }
 
-        Symbol* s = toSymbol(se.var);
+        Symbol* s = toSymbolNRVO(se.var);
 
         // VarExp generated for `__traits(initSymbol, Aggregate)`?
         if (auto symDec = se.var.isSymbolDeclaration())
@@ -781,9 +781,7 @@ elem* toElem(Expression e, ref IRState irs)
         if (se.var.toParent2())
             fd = se.var.toParent2().isFuncDeclaration();
 
-        const bool nrvo = fd && (fd.isNRVO && fd.nrvo_var == se.var || se.var.nrvo && fd.shidden);
-        if (nrvo)
-            s = cast(Symbol*)fd.shidden;
+        const bool nrvo = fd && s == fd.shidden;
 
         if (s.Sclass == SC.auto_ || s.Sclass == SC.parameter || s.Sclass == SC.shadowreg)
         {
@@ -4419,7 +4417,7 @@ elem* toElemRVO(Expression e, elem* ehidden, ref IRState irs, Type forceType = n
          * replace it with ehidden.
          */
         if (ehidden.Eoper == OPvar && ehidden.Voffset == 0 &&
-            ehidden.Vsym == toSymbol(ve.var))
+            ehidden.Vsym == toSymbolNRVO(ve.var))
         {
             if (tybasic(ehidden.Ety) == TYnptr)
             {

compiler/src/dmd/glue/s2ir.d

@@ -38,7 +38,7 @@ import dmd.dsymbol;
 import dmd.dstruct;
 import dmd.dtemplate;
 import dmd.expression;
-import dmd.expressionsem : getDsymbol, toInteger;
+import dmd.expressionsem : canElideCopy, getDsymbol, toInteger;
 import dmd.func;
 import dmd.id;
 import dmd.init;
@@ -559,29 +559,34 @@ void Statement_toIR(Statement s, ref IRState irs, StmtState* stmtstate)
     void visitReturn(ReturnStatement s)
     {
         //printf("s2ir.ReturnStatement: %s\n", toChars(s.exp));
-        BlockState* blx = irs.blx;
-        BC bc;
 
         incUsage(irs, s.loc);
-        void finish()
+        void finish(elem* e = null)
         {
-            block* finallyBlock;
-            if (config.ehmethod != EHmethod.EH_DWARF &&
-                !irs.isNothrow() &&
-                (finallyBlock = stmtstate.getFinallyBlock()) != null)
+            BC bc = BC.ret;
+            BlockState* blx = irs.blx;
+
+            if (e)
             {
-                assert(finallyBlock.bc == BC.finally_);
-                blx.curblock.Bsucc.push(finallyBlock);
+                elem_setLoc(e, s.loc);
+                block_appendexp(blx.curblock, e);
+                bc = BC.retexp;
+            }
+
+            if (config.ehmethod != EHmethod.EH_DWARF && !irs.isNothrow())
+            {
+                if (block* finallyBlock = stmtstate.getFinallyBlock())
+                {
+                    assert(finallyBlock.bc == BC.finally_);
+                    blx.curblock.Bsucc.push(finallyBlock);
+                }
             }
 
             block_setLoc(blx.curblock, s.loc);
             block_next(blx, bc, null);
         }
         if (!s.exp)
-        {
-            bc = BC.ret;
             return finish();
-        }
 
         elem* e;
 
@@ -590,78 +595,30 @@ void Statement_toIR(Statement s, ref IRState irs, StmtState* stmtstate)
         auto tf = func.type.isTypeFunction();
         assert(tf);
 
-        RET retmethod = retStyle(tf, func.needThis());
-        if (retmethod == RET.stack)
+        if (retStyle(tf, func.needThis()) == RET.stack)
         {
-            elem* es;
-            bool writetohp;
+            bool nrvo = func.isNRVO && func.nrvo_var;
+            bool urvo = !nrvo && canElideCopy(s.exp, s.exp.type);
 
-            /* If returning struct literal, write result
-             * directly into return value
-             */
-            if (auto sle = s.exp.isStructLiteralExp())
-            {
-                sle.sym = irs.shidden;
-                writetohp = true;
-            }
-            /* Detect function call that returns the same struct
-             * and construct directly into *shidden
-             */
-            else if (auto ce = s.exp.isCallExp())
-            {
-                if (ce.e1.op == EXP.variable || ce.e1.op == EXP.star)
-                {
-                    Type t = ce.e1.type.toBasetype();
-                    if (t.ty == Tdelegate)
-                        t = t.nextOf();
-                    if (t.ty == Tfunction && retStyle(cast(TypeFunction)t, ce.f && ce.f.needThis()) == RET.stack)
-                    {
-                        e = toElemDtor(s.exp, irs, el_var(irs.shidden));
-                        e = el_una(OPaddr, TYnptr, e);
-                        goto L1;
-                    }
-                }
-                else if (auto dve = ce.e1.isDotVarExp())
-                {
-                    auto fd = dve.var.isFuncDeclaration();
-                    if (fd && fd.isCtorDeclaration())
-                    {
-                        if (auto sle = dve.e1.isStructLiteralExp())
-                        {
-                            sle.sym = irs.shidden;
-                            writetohp = true;
-                        }
-                    }
-                    Type t = ce.e1.type.toBasetype();
-                    if (t.ty == Tdelegate)
-                        t = t.nextOf();
-                    if (t.ty == Tfunction && retStyle(cast(TypeFunction)t, fd && fd.needThis()) == RET.stack)
-                    {
-                        e = toElemDtor(s.exp, irs, el_var(irs.shidden));
-                        e = el_una(OPaddr, TYnptr, e);
-                        goto L1;
-                    }
-                }
-            }
-            e = toElemDtor(s.exp, irs);
+            // Pass shidden in ehidden for URVO
+            elem* ehidden = urvo ? el_var(irs.shidden) : null;
+            e = toElemDtor(s.exp, irs, ehidden);
             assert(e);
 
-            if (writetohp ||
-                (func.isNRVO && func.nrvo_var))
+            if (nrvo || urvo)
             {
-                // Return value via hidden pointer passed as parameter
-                // Write exp; return shidden;
-                es = e;
+                // For URVO, toElemDtor already returns the hidden pointer
+                // so there is no need to rewrite
+                e = el_una(OPaddr, TYnptr, e);
             }
             else
             {
                 // Return value via hidden pointer passed as parameter
                 // Write *shidden=exp; return shidden;
-                es = el_una(OPind,e.Ety,el_var(irs.shidden));
+                elem* es = el_una(OPind, e.Ety, el_var(irs.shidden));
                 es = elAssign(es, e, s.exp.type, null);
+                e = el_combine(es, el_var(irs.shidden));
             }
-            e = el_var(irs.shidden);
-            e = el_bin(OPcomma, e.Ety, es, e);
         }
         else if (tf.isRef)
         {
@@ -674,13 +631,8 @@ void Statement_toIR(Statement s, ref IRState irs, StmtState* stmtstate)
             e = toElemDtor(s.exp, irs);
             assert(e);
         }
-    L1:
-        elem_setLoc(e, s.loc);
-        block_appendexp(blx.curblock, e);
-        bc = BC.retexp;
-//        if (type_zeroCopy(Type_toCtype(s.exp.type)))
-//            bc = BC.ret;
-        finish();
+
+        finish(e);
     }
 
     /**************************************

compiler/src/dmd/glue/tocsym.d

@@ -179,6 +179,11 @@ Symbol* toSymbol(Type t)
 }
 
 /*************************************
+ * Turn a D symbol into a C Symbol.
+ * Params:
+ *      s = D symbol
+ * Returns:
+ *      corresponding Symbol
  */
 package(dmd.glue)
 Symbol* toSymbol(Dsymbol s)
@@ -647,6 +652,44 @@ Symbol* toSymbol(Dsymbol s)
     return v.result;
 }
 
+/*************************************
+ * Turn a D symbol into a C Symbol, but
+ * also substitute NRVO variables for the
+ * hidden symbol along the way.
+ *
+ * Params:
+ *      s = D symbol
+ * Returns:
+ *      corresponding Symbol
+ */
+package(dmd.glue)
+Symbol* toSymbolNRVO(Dsymbol s)
+{
+    if (auto parent = s.toParent2())
+    {
+        auto fd = parent.isFuncDeclaration();
+        auto var = s.isVarDeclaration();
+
+        if (fd && var &&
+            (fd.isNRVO && fd.nrvo_var == var ||
+             fd.shidden && var.nrvo))
+        {
+            auto shidden = cast(Symbol*)fd.shidden;
+
+            /* Nested function accessing NRVO variable.
+             * Consider the variable volatile in the same way
+             * other variables with nested ref do.
+             */
+            if (var.nestedrefs.length)
+                type_setcv(&shidden.Stype, shidden.Stype.Tty | mTYvolatile);
+
+            return shidden;
+        }
+    }
+
+    return toSymbol(s);
+}
+
 
 /*********************************
  * Generate import symbol from symbol.

compiler/test/runnable/nrvo.d

@@ -89,6 +89,16 @@ out(v; v.ptr == &v)
     return b3 ? make3() : f3();
 }
 
+S3 h3()
+{
+    static S3 lazyS3(lazy S3 s)
+    {
+        return s();
+    }
+
+    return b3 ? assert(0) : lazyS3(f3());
+}
+
 void test3()
 {
     S3 s1 = f3();
@@ -121,6 +131,10 @@ void test3()
     }
 
     f3().b.check();
+
+    S3 s5 = h3();
+    s5.check();
+    assert(i3 == 5);
 }
 
 /***************************************************/