DFuncValue: Add explicit funcPtr field

As preparation for using a LL pair as rvalue if the expression type
is Tdelegate.

Author: kinke

gen/dvalue.cpp

@@ -105,13 +105,14 @@ LLValue *DSliceValue::getPtr() {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-DFuncValue::DFuncValue(Type *t, FuncDeclaration *fd, LLValue *v, LLValue *vt,
-                       LLValue *vtable)
-    : DRValue(t, v), func(fd), vthis(vt), vtable(vtable) {}
+DFuncValue::DFuncValue(Type *t, FuncDeclaration *fd, LLValue *funcPtr,
+                       LLValue *vt, LLValue *vtable)
+    : DRValue(t, funcPtr), func(fd), funcPtr(funcPtr), vthis(vt),
+      vtable(vtable) {}
 
-DFuncValue::DFuncValue(FuncDeclaration *fd, LLValue *v, LLValue *vt,
+DFuncValue::DFuncValue(FuncDeclaration *fd, LLValue *funcPtr, LLValue *vt,
                        LLValue *vtable)
-    : DFuncValue(fd->type, fd, v, vt, vtable) {}
+    : DFuncValue(fd->type, fd, funcPtr, vt, vtable) {}
 
 bool DFuncValue::definedInFuncEntryBB() {
   return isDefinedInFuncEntryBB(val) &&

gen/dvalue.h

@@ -141,14 +141,15 @@ class DSliceValue : public DRValue {
 /// optional vtable pointer.
 class DFuncValue : public DRValue {
 public:
-  FuncDeclaration *func;
-  llvm::Value *vthis;
+  FuncDeclaration *const func;
+  llvm::Value *const funcPtr;
+  llvm::Value *const vthis;
   llvm::Value *vtable;
 
-  DFuncValue(Type *t, FuncDeclaration *fd, llvm::Value *v,
+  DFuncValue(Type *t, FuncDeclaration *fd, llvm::Value *funcPtr,
+             llvm::Value *vt = nullptr, llvm::Value *vtable = nullptr);
+  DFuncValue(FuncDeclaration *fd, llvm::Value *funcPtr,
              llvm::Value *vt = nullptr, llvm::Value *vtable = nullptr);
-  DFuncValue(FuncDeclaration *fd, llvm::Value *v, llvm::Value *vt = nullptr,
-             llvm::Value *vtable = nullptr);
 
   bool definedInFuncEntryBB() override;
 

gen/llvmhelpers.cpp

@@ -767,7 +767,7 @@ DValue *DtoPaintType(const Loc &loc, DValue *val, Type *to) {
     }
   } else if (auto func = val->isFunc()) {
     if (tb->ty == TY::Tdelegate) {
-      return new DFuncValue(to, func->func, DtoRVal(func), func->vthis);
+      return new DFuncValue(to, func->func, func->funcPtr, func->vthis);
     }
   } else { // generic rvalue
     LLValue *rval = DtoRVal(val);

gen/toir.cpp

@@ -984,11 +984,10 @@ class ToElemVisitor : public Visitor {
     // function pointers are special
     if (e->type->toBasetype()->ty == TY::Tfunction) {
       DValue *dv = toElem(e->e1);
-      LLValue *llVal = DtoRVal(dv);
       if (DFuncValue *dfv = dv->isFunc()) {
-        result = new DFuncValue(e->type, dfv->func, llVal);
+        result = new DFuncValue(e->type, dfv->func, dfv->funcPtr);
       } else {
-        result = new DImValue(e->type, llVal);
+        result = new DImValue(e->type, DtoRVal(dv));
       }
       return;
     }
@@ -1072,18 +1071,18 @@ class ToElemVisitor : public Visitor {
                             fdecl->visibility.kind != Visibility::package_;
 
       // Get the actual function value to call.
-      LLValue *funcval = nullptr;
+      LLValue *funcPtr = nullptr;
       LLValue *vtable = nullptr;
       if (nonFinal) {
         DtoResolveFunction(fdecl);
-        std::tie(funcval, vtable) = DtoVirtualFunctionPointer(l, fdecl);
+        std::tie(funcPtr, vtable) = DtoVirtualFunctionPointer(l, fdecl);
       } else {
-        funcval = DtoCallee(fdecl);
+        funcPtr = DtoCallee(fdecl);
       }
-      assert(funcval);
+      assert(funcPtr);
 
       LLValue *vthis = (DtoIsInMemoryOnly(l->type) ? DtoLVal(l) : DtoRVal(l));
-      result = new DFuncValue(fdecl, funcval, vthis, vtable);
+      result = new DFuncValue(fdecl, funcPtr, vthis, vtable);
     } else {
       llvm_unreachable("Unknown target for VarDeclaration.");
     }