DFuncValue: Store LL pair as rvalue for delegates

Author: kinke

gen/dvalue.cpp

@@ -105,11 +105,23 @@ LLValue *DSliceValue::getPtr() {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace {
+LLValue *createFuncRValue(Type *t, LLValue *funcPtr, LLValue *vthis) {
+  if (t->toBasetype()->ty == TY::Tdelegate) {
+    assert(vthis);
+    return DtoAggrPair(vthis, funcPtr);
+  }
+  return funcPtr;
+}
+}
+
 DFuncValue::DFuncValue(Type *t, FuncDeclaration *fd, LLValue *funcPtr,
                        LLValue *vt, LLValue *vtable)
-    : DRValue(t, funcPtr), func(fd), funcPtr(funcPtr), vthis(vt),
-      vtable(vtable) {
+    : DRValue(t, createFuncRValue(t, funcPtr, vt)), func(fd), funcPtr(funcPtr),
+      vthis(vt), vtable(vtable) {
+#ifndef NDEBUG
   const auto tb = t->toBasetype();
+#endif
   assert(tb->ty == TY::Tfunction || tb->ty == TY::Tdelegate ||
          (tb->ty == TY::Tpointer &&
           tb->nextOf()->toBasetype()->ty == TY::Tfunction));

gen/toir.cpp

@@ -947,8 +947,9 @@ class ToElemVisitor : public Visitor {
       // Logger::println("FuncDeclaration");
       FuncDeclaration *fd = fv->func;
       assert(fd);
-      result =
-          fv->type == e->type ? fv : new DFuncValue(e->type, fd, fv->funcPtr);
+      result = fv->type == e->type
+                   ? fv
+                   : new DFuncValue(e->type, fd, fv->funcPtr, fv->vthis);
       return;
     }
     if (v->isIm()) {
@@ -986,9 +987,10 @@ class ToElemVisitor : public Visitor {
     if (e->type->toBasetype()->ty == TY::Tfunction) {
       DValue *dv = toElem(e->e1);
       if (DFuncValue *dfv = dv->isFunc()) {
-        result = dfv->type == e->type
-                     ? dfv
-                     : new DFuncValue(e->type, dfv->func, dfv->funcPtr);
+        result =
+            dfv->type == e->type
+                ? dfv
+                : new DFuncValue(e->type, dfv->func, dfv->funcPtr, dfv->vthis);
       } else {
         // FIXME: should not reach this
         result = new DImValue(e->type, DtoRVal(dv));
@@ -1955,9 +1957,11 @@ class ToElemVisitor : public Visitor {
     DValue *u = toElem(e->e1);
     LLValue *contextptr;
     if (DFuncValue *f = u->isFunc()) {
-      assert(f->func);
-      // FIXME: use f->vthis
-      contextptr = DtoNestedContext(e->loc, f->func);
+      contextptr = f->vthis;
+      if (!contextptr) {
+        assert(f->func);
+        contextptr = DtoNestedContext(e->loc, f->func);
+      }
     } else {
       contextptr = (DtoIsInMemoryOnly(u->type) ? DtoLVal(u) : DtoRVal(u));
     }
@@ -1993,9 +1997,7 @@ class ToElemVisitor : public Visitor {
       fptr = DtoCallee(e->func);
     }
 
-    // FIXME: use DFuncValue
-    result = new DImValue(
-        e->type, DtoAggrPair(DtoType(e->type), contextptr, fptr, ".dg"));
+    result = new DFuncValue(e->type, e->func, fptr, contextptr);
   }
 
   //////////////////////////////////////////////////////////////////////////////
@@ -2286,11 +2288,11 @@ class ToElemVisitor : public Visitor {
     genFuncLiteral(fd, e);
     LLFunction *callee = DtoCallee(fd, false);
 
-    if (fd->isNested()) { // FIXME: if e->type->toBasetype() is a Tdelegate?
+    if (e->type->toBasetype()->ty == TY::Tdelegate) {
       LLValue *cval = DtoNestedContext(e->loc, fd);
-      // FIXME: use DFuncValue
-      result = new DImValue(e->type, DtoAggrPair(cval, callee, ".func"));
+      result = new DFuncValue(e->type, fd, callee, cval);
     } else {
+      assert(!fd->isNested());
       result = new DFuncValue(e->type, fd, callee);
     }
   }