Expose constructing a virtual method dispatch through the include/clang/CodeGen APIs.

[pschuh]

Summary

In swift, we want to be able to call c++ virtual methods by looking up in the virtual table. There appears to exist no way currently, via the standard APIs, to take a CXXMethodDecl and a llvm::Value representing a this-ptr and construct the llvm instructions necessary to extract the method from the virtual table as well as adjust the this-ptr.

For reference, this is used in https://github.com/apple/swift/pull/26658.

[rjmccall]

include/clang/CodeGen/SwiftCallingConv.h

190

This isn't the right header for this. More thoughts on this point below.

The documentation should describe the expected relationship between this and the method. I imagine that thisPtr is expected to already be a pointer to the type which declares the method (i.e. MD->getParent()), and in the appropriate address space.

Please name this something like emitLoadOfCXXVirtualMethod.

This particular case will probably never need control flow or temporary memory, but I wonder if we should go ahead and introduce an abstraction that bundles the CGM and the builder so that we can teach it to handle those in the future. If you do, you could just define it in its own header and then make this a method on that.

I think it would be totally reasonable to pull Clang's Address.h up to include/clang/CodeGen instead of breaking it down here.

Also, this really needs to return a CGCallee, which might require pulling that up as well. The reason why should be clear in a few weeks.

[pschuh]

Your suggestions of pulling the builder out as an API and exposing CGCallee made everything a lot simpler. Unfortunately, I had to split the CGCallee header because it threatened to pull EHScopeStack.h and CGValue.h to be public (and transitively CodeGenTBAA.h). The old CGCall.h header now just contains the Args and ReturnValueSlot.

[pschuh]

Hi John, maybe take a look?

include/clang/CodeGen/CodeGenABITypes.h

 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM,
                                               CanQual<FunctionNoProtoType> Ty);
 
 const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM,
                                            const CXXRecordDecl *RD,
                                            const FunctionProtoType *FTP,
                                            const CXXMethodDecl *MD);
 
+const CGFunctionInfo &arrangeCXXMethodDeclaration(CodeGenModule &CGM,
+                                                  const CXXMethodDecl *MD);
+
 const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM,
                                               CanQualType returnType,
                                               ArrayRef<CanQualType> argTypes,
                                               FunctionType::ExtInfo info,
                                               RequiredArgs args);
 
 /// Returns null if the function type is incomplete and can't be lowered.
 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
                                             const FunctionDecl *FD);
 
+llvm::FunctionType *getFunctionType(CodeGenModule &CGM,
+                                    const CGFunctionInfo &FI);
+
 llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T);
 
 /// Given a non-bitfield struct field, return its index within the elements of
 /// the struct's converted type.  The returned index refers to a field number in
 /// the complete object type which is returned by convertTypeForMemory.  FD must
 /// be a field in RD directly (i.e. not an inherited field).
 unsigned getLLVMFieldNumber(CodeGenModule &CGM,
                             const RecordDecl *RD, const FieldDecl *FD);

include/clang/CodeGen/SwiftCallingConv.h

 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Type.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <cassert>
 
 namespace llvm {
   class IntegerType;
   class Type;
+  class Value;
   class StructType;
   class VectorType;
+  class FunctionType;
+  class IRBuilderBase;
 }
 
 namespace clang {
 class Decl;
 class FieldDecl;
 class ASTRecordLayout;
+class CXXMethodDecl;
 
 namespace CodeGen {
 class ABIArgInfo;
 class CodeGenModule;
 class CGFunctionInfo;
 
 namespace swiftcall {
 

 
 /// Compute the ABI information of a swiftcall function.  This is a
 /// private interface for Clang.
 void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
 
 /// Is swifterror lowered to a register by the target ABI?
 bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM);
 
+/// Lookup a virtual method `MD` from the vtable and adjusts the this ptr.
+llvm::Value *lowerCXXVirtualMethodDeclReference(CodeGenModule &CGM,
+                                                const CXXMethodDecl *MD,
+                                                llvm::Value *&thisPtr,
+                                                CharUnits alignment,
+                                                llvm::FunctionType *type,
+                                                llvm::IRBuilderBase *builder);
+
 } // end namespace swiftcall
 } // end namespace CodeGen
 } // end namespace clang
 
 #endif

lib/CodeGen/CodeGenABITypes.cpp

 CodeGen::arrangeCXXMethodType(CodeGenModule &CGM,
                               const CXXRecordDecl *RD,
                               const FunctionProtoType *FTP,
                               const CXXMethodDecl *MD) {
   return CGM.getTypes().arrangeCXXMethodType(RD, FTP, MD);
 }
 
 const CGFunctionInfo &
+CodeGen::arrangeCXXMethodDeclaration(CodeGenModule &CGM,
+                                     const CXXMethodDecl *MD) {
+  return CGM.getTypes().arrangeCXXMethodDeclaration(MD);
+}
+
+llvm::FunctionType *CodeGen::getFunctionType(CodeGenModule &CGM,
+                                             const CGFunctionInfo &FI) {
+  return CGM.getTypes().GetFunctionType(FI);
+}
+
+const CGFunctionInfo &
 CodeGen::arrangeFreeFunctionCall(CodeGenModule &CGM,
                                  CanQualType returnType,
                                  ArrayRef<CanQualType> argTypes,
                                  FunctionType::ExtInfo info,
                                  RequiredArgs args) {
   return CGM.getTypes().arrangeLLVMFunctionInfo(
       returnType, /*instanceMethod=*/false, /*chainCall=*/false, argTypes,
       info, {}, args);

lib/CodeGen/SwiftCallingConv.cpp

 //===--- SwiftCallingConv.cpp - Lowering for the Swift calling convention -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the abstract lowering for the Swift calling convention.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/CodeGen/SwiftCallingConv.h"
-#include "clang/Basic/TargetInfo.h"
+#include "CGCXXABI.h"
+#include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "TargetInfo.h"
+#include "clang/Basic/TargetInfo.h"
 
 using namespace clang;
 using namespace CodeGen;
 using namespace swiftcall;
 
 static const SwiftABIInfo &getSwiftABIInfo(CodeGenModule &CGM) {
   return cast<SwiftABIInfo>(CGM.getTargetCodeGenInfo().getABIInfo());
 }
for (unsigned i = 0, e = FI.arg_size(); i != e; ++i) {
     argInfo.info = classifyArgumentType(CGM, argInfo.type);
   }
 }
 
 // Is swifterror lowered to a register by the target ABI.
 bool swiftcall::isSwiftErrorLoweredInRegister(CodeGenModule &CGM) {
   return getSwiftABIInfo(CGM).isSwiftErrorInRegister();
 }
+
+llvm::Value *swiftcall::lowerCXXVirtualMethodDeclReference(
+    CodeGenModule &CGM, const CXXMethodDecl *MD, llvm::Value *&thisPtr,
+    CharUnits alignment, llvm::FunctionType *type,
+    llvm::IRBuilderBase *builder) {
+  assert(MD->isVirtual());
+
+  CodeGenFunction CGF(CGM, true);
+  CGF.Builder.SetInsertPoint(builder->GetInsertBlock(),
+                             builder->GetInsertPoint());
+  Address thisAddr(thisPtr, alignment);
+  auto callee = CGCallee::forVirtual(nullptr, MD, thisAddr, type);
+  const CGCallee &concreteCallee = callee.prepareConcreteCallee(CGF);
+  Address newThisAddr =
+      CGM.getCXXABI().adjustThisArgumentForVirtualFunctionCall(CGF, MD,
+                                                               thisAddr, true);
+  thisPtr = newThisAddr.getPointer();
+  auto *result = concreteCallee.getFunctionPointer();
+  builder->SetInsertPoint(CGF.Builder.GetInsertBlock(),
+                          CGF.Builder.GetInsertPoint());
+  return result;
+}