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 ↗

(On Diff #215655)

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/Address.h

 //===-- Address.h - An aligned address -------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This class provides a simple wrapper for a pair of a pointer and an
 // alignment.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
-#define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
+#ifndef LLVM_CLANG_CODEGEN_ADDRESS_H
+#define LLVM_CLANG_CODEGEN_ADDRESS_H
 
 #include "llvm/IR/Constants.h"
 #include "clang/AST/CharUnits.h"
 
 namespace clang {
 namespace CodeGen {
 
 /// An aligned address.

include/clang/CodeGen/CGCallee.h

+//===--- CGCallee.h - Encapsulate calling convention details ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// These classes wrap the information about a call or function
+// definition used to handle ABI compliancy.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_CODEGEN_CGCALLEE_H
+#define LLVM_CLANG_CODEGEN_CGCALLEE_H
+
+#include "clang/AST/CanonicalType.h"
+#include "clang/AST/GlobalDecl.h"
+#include "clang/AST/Type.h"
+#include "clang/CodeGen/Address.h"
+#include "llvm/IR/Value.h"
+
+namespace clang {
+namespace CodeGen {
+
+class CodeGenFunction;
+
+/// Abstract information about a function or function prototype.
+class CGCalleeInfo {
+  /// The function prototype of the callee.
+  const FunctionProtoType *CalleeProtoTy;
+  /// The function declaration of the callee.
+  GlobalDecl CalleeDecl;
+
+public:
+  explicit CGCalleeInfo() : CalleeProtoTy(nullptr), CalleeDecl() {}
+  CGCalleeInfo(const FunctionProtoType *calleeProtoTy, GlobalDecl calleeDecl)
+      : CalleeProtoTy(calleeProtoTy), CalleeDecl(calleeDecl) {}
+  CGCalleeInfo(const FunctionProtoType *calleeProtoTy)
+      : CalleeProtoTy(calleeProtoTy), CalleeDecl() {}
+  CGCalleeInfo(GlobalDecl calleeDecl)
+      : CalleeProtoTy(nullptr), CalleeDecl(calleeDecl) {}
+
+  const FunctionProtoType *getCalleeFunctionProtoType() const {
+    return CalleeProtoTy;
+  }
+  const GlobalDecl getCalleeDecl() const { return CalleeDecl; }
+};
+
+/// All available information about a concrete callee.
+class CGCallee {
+  enum class SpecialKind : uintptr_t {
+    Invalid,
+    Builtin,
+    PseudoDestructor,
+    Virtual,
+
+    Last = Virtual
+  };
+
+  struct BuiltinInfoStorage {
+    const FunctionDecl *Decl;
+    unsigned ID;
+  };
+  struct PseudoDestructorInfoStorage {
+    const CXXPseudoDestructorExpr *Expr;
+  };
+  struct VirtualInfoStorage {
+    const CallExpr *CE;
+    GlobalDecl MD;
+    Address Addr;
+    llvm::FunctionType *FTy;
+  };
+
+  SpecialKind KindOrFunctionPointer;
+  union {
+    CGCalleeInfo AbstractInfo;
+    BuiltinInfoStorage BuiltinInfo;
+    PseudoDestructorInfoStorage PseudoDestructorInfo;
+    VirtualInfoStorage VirtualInfo;
+  };
+
+  explicit CGCallee(SpecialKind kind) : KindOrFunctionPointer(kind) {}
+
+  CGCallee(const FunctionDecl *builtinDecl, unsigned builtinID)
+      : KindOrFunctionPointer(SpecialKind::Builtin) {
+    BuiltinInfo.Decl = builtinDecl;
+    BuiltinInfo.ID = builtinID;
+  }
+
+public:
+  CGCallee() : KindOrFunctionPointer(SpecialKind::Invalid) {}
+
+  /// Construct a callee.  Call this constructor directly when this
+  /// isn't a direct call.
+  CGCallee(const CGCalleeInfo &abstractInfo, llvm::Value *functionPtr)
+      : KindOrFunctionPointer(SpecialKind(uintptr_t(functionPtr))) {
+    AbstractInfo = abstractInfo;
+    assert(functionPtr && "configuring callee without function pointer");
+    assert(functionPtr->getType()->isPointerTy());
+    assert(functionPtr->getType()->getPointerElementType()->isFunctionTy());
+  }
+
+  static CGCallee forBuiltin(unsigned builtinID,
+                             const FunctionDecl *builtinDecl) {
+    CGCallee result(SpecialKind::Builtin);
+    result.BuiltinInfo.Decl = builtinDecl;
+    result.BuiltinInfo.ID = builtinID;
+    return result;
+  }
+
+  static CGCallee forPseudoDestructor(const CXXPseudoDestructorExpr *E) {
+    CGCallee result(SpecialKind::PseudoDestructor);
+    result.PseudoDestructorInfo.Expr = E;
+    return result;
+  }
+
+  static CGCallee forDirect(llvm::Constant *functionPtr,
+                      const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
+    return CGCallee(abstractInfo, functionPtr);
+  }
+
+  static CGCallee
+  forDirect(llvm::FunctionCallee functionPtr,
+            const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
+    return CGCallee(abstractInfo, functionPtr.getCallee());
+  }
+
+  static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
+                             llvm::FunctionType *FTy) {
+    CGCallee result(SpecialKind::Virtual);
+    result.VirtualInfo.CE = CE;
+    result.VirtualInfo.MD = MD;
+    result.VirtualInfo.Addr = Addr;
+    result.VirtualInfo.FTy = FTy;
+    return result;
+  }
+
+  bool isBuiltin() const {
+    return KindOrFunctionPointer == SpecialKind::Builtin;
+  }
+  const FunctionDecl *getBuiltinDecl() const {
+    assert(isBuiltin());
+    return BuiltinInfo.Decl;
+  }
+  unsigned getBuiltinID() const {
+    assert(isBuiltin());
+    return BuiltinInfo.ID;
+  }
+
+  bool isPseudoDestructor() const {
+    return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
+  }
+  const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
+    assert(isPseudoDestructor());
+    return PseudoDestructorInfo.Expr;
+  }
+
+  bool isOrdinary() const {
+    return uintptr_t(KindOrFunctionPointer) > uintptr_t(SpecialKind::Last);
+  }
+  CGCalleeInfo getAbstractInfo() const {
+    if (isVirtual())
+      return VirtualInfo.MD;
+    assert(isOrdinary());
+    return AbstractInfo;
+  }
+  llvm::Value *getFunctionPointer() const {
+    assert(isOrdinary());
+    return reinterpret_cast<llvm::Value*>(uintptr_t(KindOrFunctionPointer));
+  }
+  void setFunctionPointer(llvm::Value *functionPtr) {
+    assert(isOrdinary());
+    KindOrFunctionPointer = SpecialKind(uintptr_t(functionPtr));
+  }
+
+  bool isVirtual() const {
+    return KindOrFunctionPointer == SpecialKind::Virtual;
+  }
+  const CallExpr *getVirtualCallExpr() const {
+    assert(isVirtual());
+    return VirtualInfo.CE;
+  }
+  GlobalDecl getVirtualMethodDecl() const {
+    assert(isVirtual());
+    return VirtualInfo.MD;
+  }
+  Address getThisAddress() const {
+    assert(isVirtual());
+    return VirtualInfo.Addr;
+  }
+  llvm::FunctionType *getVirtualFunctionType() const {
+    assert(isVirtual());
+    return VirtualInfo.FTy;
+  }
+
+  /// If this is a delayed callee computation of some sort, prepare
+  /// a concrete callee.
+  CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const;
+};
+
+}  // end namespace CodeGen
+}  // end namespace clang
+
+#endif

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/FunctionBuilder.h

+//===--- CodeGen/FunctionBuilder.h - Build LLVM from AST Decls --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the FunctionBuilder interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_CODEGEN_FUNCTIONBUILDER_H
+#define LLVM_CLANG_CODEGEN_FUNCTIONBUILDER_H
+
+#include <memory>
+#include "clang/CodeGen/Address.h"
+#include "clang/CodeGen/CGCallee.h"
+#include "clang/AST/GlobalDecl.h"
+
+namespace llvm {
+class IRBuilderBase;
+}
+
+namespace clang {
+namespace CodeGen {
+
+class CodeGenModule;
+class CodeGenFunction;
+
+/// A public api for working with a subset of the features of
+/// CodeGen::CodeGenFunction.
+///
+/// This is not really an abstract interface.
+class FunctionBuilder {
+ protected:
+  FunctionBuilder() {}
+  FunctionBuilder(const FunctionBuilder&) = delete;
+  FunctionBuilder(FunctionBuilder&&) = delete;
+
+ public:
+  virtual ~FunctionBuilder();
+
+  /// Returns an opaque reference to the underlying CodeGenFunction object.
+  /// This can be passed to other APIs and is valid for the lifetime of this
+  /// object.
+  CodeGen::CodeGenFunction &CGF();
+
+  /// Gets access to the underlying llvm builder for interop between multiple
+  /// llvm IR builders.
+  llvm::IRBuilderBase &getBuilder();
+
+  /// Perform ABI-specific "this" argument adjustment required prior to
+  /// a call of a virtual function. The "VirtualCall" argument is true iff the
+  /// call itself is virtual. `thisAddr` should already have the same type as
+  /// the function on which the virtual method is defined.
+  Address emitAdjustThisArgumentForVirtualFunctionCall(Address thisAddr,
+                                                       GlobalDecl GD,
+                                                       bool VirtualCall);
+
+  /// Creates a FunctionBuilder. CGM must outlive the result.
+  static std::unique_ptr<FunctionBuilder> Create(CodeGenModule &CGM);
+};
+
+} // end namespace CodeGen
+} // end namespace clang
+
+#endif

lib/CodeGen/CGBuilder.h

 //===-- CGBuilder.h - Choose IRBuilder implementation  ----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
 #define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
 
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IRBuilder.h"
-#include "Address.h"
+#include "clang/CodeGen/Address.h"
 #include "CodeGenTypeCache.h"
 
 namespace clang {
 namespace CodeGen {
 
 class CodeGenFunction;
 
 /// This is an IRBuilder insertion helper that forwards to

lib/CodeGen/CGCall.h

 #ifndef LLVM_CLANG_LIB_CODEGEN_CGCALL_H
 #define LLVM_CLANG_LIB_CODEGEN_CGCALL_H
 
 #include "CGValue.h"
 #include "EHScopeStack.h"
 #include "clang/AST/CanonicalType.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/Type.h"
+#include "clang/CodeGen/CGCallee.h"
 #include "llvm/IR/Value.h"
 
-// FIXME: Restructure so we don't have to expose so much stuff.
-#include "ABIInfo.h"
-
 namespace llvm {
 class AttributeList;
 class Function;
 class Type;
 class Value;
 }
 
 namespace clang {
   class ASTContext;
   class Decl;
   class FunctionDecl;
   class ObjCMethodDecl;
   class VarDecl;
 
 namespace CodeGen {
 
-/// Abstract information about a function or function prototype.
-class CGCalleeInfo {
-  /// The function prototype of the callee.
-  const FunctionProtoType *CalleeProtoTy;
-  /// The function declaration of the callee.
-  GlobalDecl CalleeDecl;
-
-public:
-  explicit CGCalleeInfo() : CalleeProtoTy(nullptr), CalleeDecl() {}
-  CGCalleeInfo(const FunctionProtoType *calleeProtoTy, GlobalDecl calleeDecl)
-      : CalleeProtoTy(calleeProtoTy), CalleeDecl(calleeDecl) {}
-  CGCalleeInfo(const FunctionProtoType *calleeProtoTy)
-      : CalleeProtoTy(calleeProtoTy), CalleeDecl() {}
-  CGCalleeInfo(GlobalDecl calleeDecl)
-      : CalleeProtoTy(nullptr), CalleeDecl(calleeDecl) {}
-
-  const FunctionProtoType *getCalleeFunctionProtoType() const {
-    return CalleeProtoTy;
-  }
-  const GlobalDecl getCalleeDecl() const { return CalleeDecl; }
-  };
-
-  /// All available information about a concrete callee.
-  class CGCallee {
-    enum class SpecialKind : uintptr_t {
-      Invalid,
-      Builtin,
-      PseudoDestructor,
-      Virtual,
-
-      Last = Virtual
-    };
-
-    struct BuiltinInfoStorage {
-      const FunctionDecl *Decl;
-      unsigned ID;
-    };
-    struct PseudoDestructorInfoStorage {
-      const CXXPseudoDestructorExpr *Expr;
-    };
-    struct VirtualInfoStorage {
-      const CallExpr *CE;
-      GlobalDecl MD;
-      Address Addr;
-      llvm::FunctionType *FTy;
-    };
-
-    SpecialKind KindOrFunctionPointer;
-    union {
-      CGCalleeInfo AbstractInfo;
-      BuiltinInfoStorage BuiltinInfo;
-      PseudoDestructorInfoStorage PseudoDestructorInfo;
-      VirtualInfoStorage VirtualInfo;
-    };
-
-    explicit CGCallee(SpecialKind kind) : KindOrFunctionPointer(kind) {}
-
-    CGCallee(const FunctionDecl *builtinDecl, unsigned builtinID)
-        : KindOrFunctionPointer(SpecialKind::Builtin) {
-      BuiltinInfo.Decl = builtinDecl;
-      BuiltinInfo.ID = builtinID;
-    }
-
-  public:
-    CGCallee() : KindOrFunctionPointer(SpecialKind::Invalid) {}
-
-    /// Construct a callee.  Call this constructor directly when this
-    /// isn't a direct call.
-    CGCallee(const CGCalleeInfo &abstractInfo, llvm::Value *functionPtr)
-        : KindOrFunctionPointer(SpecialKind(uintptr_t(functionPtr))) {
-      AbstractInfo = abstractInfo;
-      assert(functionPtr && "configuring callee without function pointer");
-      assert(functionPtr->getType()->isPointerTy());
-      assert(functionPtr->getType()->getPointerElementType()->isFunctionTy());
-    }
-
-    static CGCallee forBuiltin(unsigned builtinID,
-                               const FunctionDecl *builtinDecl) {
-      CGCallee result(SpecialKind::Builtin);
-      result.BuiltinInfo.Decl = builtinDecl;
-      result.BuiltinInfo.ID = builtinID;
-      return result;
-    }
-
-    static CGCallee forPseudoDestructor(const CXXPseudoDestructorExpr *E) {
-      CGCallee result(SpecialKind::PseudoDestructor);
-      result.PseudoDestructorInfo.Expr = E;
-      return result;
-    }
-
-    static CGCallee forDirect(llvm::Constant *functionPtr,
-                        const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
-      return CGCallee(abstractInfo, functionPtr);
-    }
-
-    static CGCallee
-    forDirect(llvm::FunctionCallee functionPtr,
-              const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
-      return CGCallee(abstractInfo, functionPtr.getCallee());
-    }
-
-    static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
-                               llvm::FunctionType *FTy) {
-      CGCallee result(SpecialKind::Virtual);
-      result.VirtualInfo.CE = CE;
-      result.VirtualInfo.MD = MD;
-      result.VirtualInfo.Addr = Addr;
-      result.VirtualInfo.FTy = FTy;
-      return result;
-    }
-
-    bool isBuiltin() const {
-      return KindOrFunctionPointer == SpecialKind::Builtin;
-    }
-    const FunctionDecl *getBuiltinDecl() const {
-      assert(isBuiltin());
-      return BuiltinInfo.Decl;
-    }
-    unsigned getBuiltinID() const {
-      assert(isBuiltin());
-      return BuiltinInfo.ID;
-    }
-
-    bool isPseudoDestructor() const {
-      return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
-    }
-    const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
-      assert(isPseudoDestructor());
-      return PseudoDestructorInfo.Expr;
-    }
-
-    bool isOrdinary() const {
-      return uintptr_t(KindOrFunctionPointer) > uintptr_t(SpecialKind::Last);
-    }
-    CGCalleeInfo getAbstractInfo() const {
-      if (isVirtual())
-        return VirtualInfo.MD;
-      assert(isOrdinary());
-      return AbstractInfo;
-    }
-    llvm::Value *getFunctionPointer() const {
-      assert(isOrdinary());
-      return reinterpret_cast<llvm::Value*>(uintptr_t(KindOrFunctionPointer));
-    }
-    void setFunctionPointer(llvm::Value *functionPtr) {
-      assert(isOrdinary());
-      KindOrFunctionPointer = SpecialKind(uintptr_t(functionPtr));
-    }
-
-    bool isVirtual() const {
-      return KindOrFunctionPointer == SpecialKind::Virtual;
-    }
-    const CallExpr *getVirtualCallExpr() const {
-      assert(isVirtual());
-      return VirtualInfo.CE;
-    }
-    GlobalDecl getVirtualMethodDecl() const {
-      assert(isVirtual());
-      return VirtualInfo.MD;
-    }
-    Address getThisAddress() const {
-      assert(isVirtual());
-      return VirtualInfo.Addr;
-    }
-    llvm::FunctionType *getVirtualFunctionType() const {
-      assert(isVirtual());
-      return VirtualInfo.FTy;
-    }
-
-    /// If this is a delayed callee computation of some sort, prepare
-    /// a concrete callee.
-    CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const;
-  };
-
   struct CallArg {
   private:
     union {
       RValue RV;
       LValue LV; /// The argument is semantically a load from this l-value.
     };
     bool HasLV;
 

lib/CodeGen/CGCleanup.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H
 #define LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H
 
 #include "EHScopeStack.h"
 
-#include "Address.h"
+#include "clang/CodeGen/Address.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 class BasicBlock;
 class Value;
 class ConstantInt;
 class AllocaInst;

lib/CodeGen/CGObjCRuntime.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOBJCRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGOBJCRUNTIME_H
 #include "CGBuilder.h"
 #include "CGCall.h"
 #include "CGCleanup.h"
 #include "CGValue.h"
+#include "ABIInfo.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/IdentifierTable.h" // Selector
 
 namespace llvm {
   class Constant;
   class Function;
   class Module;
   class StructLayout;

lib/CodeGen/CGValue.h

 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGVALUE_H
 #define LLVM_CLANG_LIB_CODEGEN_CGVALUE_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/Type.h"
-#include "Address.h"
+#include "clang/CodeGen/Address.h"
 #include "CodeGenTBAA.h"
 
 namespace llvm {
   class Constant;
   class MDNode;
 }
 
 namespace clang {

lib/CodeGen/CMakeLists.txt

add_clang_library(clangCodeGen
   CodeGenAction.cpp
   CodeGenFunction.cpp
   CodeGenModule.cpp
   CodeGenPGO.cpp
   CodeGenTBAA.cpp
   CodeGenTypes.cpp
   ConstantInitBuilder.cpp
   CoverageMappingGen.cpp
+  FunctionBuilder.cpp
   ItaniumCXXABI.cpp
   MacroPPCallbacks.cpp
   MicrosoftCXXABI.cpp
   ModuleBuilder.cpp
   ObjectFilePCHContainerOperations.cpp
   PatternInit.cpp
   SanitizerMetadata.cpp
   SwiftCallingConv.cpp

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/FunctionBuilder.cpp

+//===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This exposes a subset of the CodeGenFunction API.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/CodeGen/FunctionBuilder.h"
+#include "CGCXXABI.h"
+#include "CodeGenFunction.h"
+#include "clang/Basic/TargetInfo.h"
+
+using namespace clang;
+using namespace CodeGen;
+
+namespace {
+class FunctionBuilderImpl : public FunctionBuilder {
+ public:
+  CodeGenFunction CGF;
+
+  FunctionBuilderImpl(CodeGenModule &CGM)
+      : CGF(CGM, /*suppressNewContext=*/true) {}
+};
+} // namespace
+
+FunctionBuilder::~FunctionBuilder() {}
+
+std::unique_ptr<FunctionBuilder> FunctionBuilder::Create(CodeGenModule &CGM) {
+  return std::unique_ptr<FunctionBuilder>(new FunctionBuilderImpl(CGM));
+}
+
+CodeGenFunction &FunctionBuilder::CGF() {
+  return static_cast<FunctionBuilderImpl *>(this)->CGF;
+}
+
+llvm::IRBuilderBase &FunctionBuilder::getBuilder() { return CGF().Builder; }
+
+Address FunctionBuilder::emitAdjustThisArgumentForVirtualFunctionCall(
+    Address thisAddr, GlobalDecl GD, bool VirtualCall) {
+  return CGF().CGM.getCXXABI().adjustThisArgumentForVirtualFunctionCall(
+      CGF(), GD, thisAddr, VirtualCall);
+}