Merge pull request #427 from AlexeyProkhin/issue426

Fixed issue #426 — dtor / destructor not called for (rvalue) struct used in opApply

gen/irstate.h

@@ -72,9 +72,6 @@ struct IRScope
     IRScope(llvm::BasicBlock* b, llvm::BasicBlock* e);
 
     const IRScope& operator=(const IRScope& rhs);
-
-    // list of variables needing destruction
-    std::vector<VarDeclaration*> varsInScope;
 };
 
 struct IRBuilderHelper
@@ -157,7 +154,6 @@ struct IRState
     // basic block scopes
     std::vector<IRScope> scopes;
     IRScope& scope();
-    std::vector<VarDeclaration*> &varsInScope() { return scope().varsInScope; }
     llvm::BasicBlock* scopebb();
     llvm::BasicBlock* scopeend();
     bool scopereturned();

gen/llvmhelpers.cpp

@@ -1073,7 +1073,7 @@ void DtoVarDeclaration(VarDeclaration* vd)
                         {
                             vd->ir.irLocal->value = val;
                         }
-                        goto Lexit;
+                        return;
                     }
                 }
             }
@@ -1105,15 +1105,6 @@ void DtoVarDeclaration(VarDeclaration* vd)
             ex->exp->toElem(gIR);
         }
     }
-
-Lexit:
-    /* Mark the point of construction of a variable that needs to be destructed.
-     */
-    if (vd->edtor && !vd->noscope)
-    {
-        // Put vd on list of things needing destruction
-        gIR->varsInScope().push_back(vd);
-    }
 }
 
 DValue* DtoDeclarationExp(Dsymbol* declaration)

gen/toir.cpp

@@ -38,6 +38,7 @@
 #include "gen/warnings.h"
 #include "ir/irtypeclass.h"
 #include "ir/irtypestruct.h"
+#include "ir/irlandingpad.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include <fstream>
@@ -64,23 +65,90 @@ void Expression::cacheLvalue(IRState* irs)
  * Evaluate Expression, then call destructors on any temporaries in it.
  */
 
-DValue *Expression::toElemDtor(IRState *irs)
+DValue *Expression::toElemDtor(IRState *p)
 {
     Logger::println("Expression::toElemDtor(): %s", toChars());
     LOG_SCOPE
 
-    size_t starti = irs->varsInScope().size();
-    DValue *val = toElem(irs);
-    size_t endi = irs->varsInScope().size();
+    class CallDestructors : public IRLandingPadCatchFinallyInfo {
+    public:
+        CallDestructors(const std::vector<Expression*> &edtors_)
+            : edtors(edtors_)
+        {}
 
-    // Add destructors
-    while (endi-- > starti)
-    {
-        VarDeclaration *vd = gIR->varsInScope().back();
-        gIR->varsInScope().pop_back();
-        vd->edtor->toElem(gIR);
+        const std::vector<Expression*> &edtors;
+
+        void toIR(LLValue */*eh_ptr*/ = 0)
+        {
+            std::vector<Expression*>::const_reverse_iterator itr, end = edtors.rend();
+            for (itr = edtors.rbegin(); itr != end; ++itr)
+                (*itr)->toElem(gIR);
+        }
+
+        static int searchVarsWithDesctructors(Expression *exp, void *edtors)
+        {
+            if (exp->op == TOKdeclaration) {
+                DeclarationExp *de = (DeclarationExp*)exp;
+                if (VarDeclaration *vd = de->declaration->isVarDeclaration()) {
+                    while (vd->aliassym) {
+                        vd = vd->aliassym->isVarDeclaration();
+                        if (!vd)
+                            return 0;
+                    }
+
+                    if (vd->init) {
+                        if (ExpInitializer *ex = vd->init->isExpInitializer())
+                            ex->exp->apply(&searchVarsWithDesctructors, edtors);
+                    }
+
+                    if (!vd->isDataseg() && vd->edtor && !vd->noscope)
+                        static_cast<std::vector<Expression*>*>(edtors)->push_back(vd->edtor);
+                }
+            }
+            return 0;
+        }
+    };
+
+
+    // find destructors that must be called
+    std::vector<Expression*> edtors;
+    apply(&CallDestructors::searchVarsWithDesctructors, &edtors);
+
+    if (!edtors.empty()) {
+        if (op == TOKcall) {
+            // create finally block that calls destructors on temporaries
+            CallDestructors *callDestructors = new CallDestructors(edtors);
+
+            // create landing pad
+            llvm::BasicBlock *oldend = p->scopeend();
+            llvm::BasicBlock *landingpadbb = llvm::BasicBlock::Create(gIR->context(), "landingpad", p->topfunc(), oldend);
+
+            // set up the landing pad
+            IRLandingPad &pad = gIR->func()->gen->landingPadInfo;
+            pad.addFinally(callDestructors);
+            pad.push(landingpadbb);
+
+            // evaluate the expression
+            DValue *val = toElem(p);
+
+            // build the landing pad
+            llvm::BasicBlock *oldbb = p->scopebb();
+            pad.pop();
+
+            // call the destructors
+            gIR->scope() = IRScope(oldbb, oldend);
+            callDestructors->toIR();
+            delete callDestructors;
+            return val;
+        } else {
+            DValue *val = toElem(p);
+            CallDestructors(edtors).toIR();
+            return val;
+        }
     }
-    return val;
+
+    return toElem(p);
+
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////