[clang] Make arrangeCXX{Constructor,Method}Call() publicly available

[mboehme]

Summary

These are needed for C++ interop in Swift. See this Swift forum discussion for details:

https://forums.swift.org/t/calling-c-constructors-looking-for-feedback-on-my-approach/34787/4?u=mboehme

[mboehme]

Abandoning this change as I've realized I'm going to need additional features, specifically those related to extra args passed for virtual base classes.

clang/include/clang/CodeGen/CodeGenABITypes.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
 #define LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
 
 #include "clang/AST/CanonicalType.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/ABI.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 
 namespace llvm {
 class Constant;
 class DataLayout;
 class Module;
 class Function;
 class FunctionType;
 class Type;
 }
 
 namespace clang {
 class ASTContext;
+class CXXConstructorDecl;
 class CXXRecordDecl;
 class CXXMethodDecl;
 class CodeGenOptions;
 class CoverageSourceInfo;
 class DiagnosticsEngine;
 class HeaderSearchOptions;
 class ObjCMethodDecl;
 class ObjCProtocolDecl;
const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM,
                                            const CXXMethodDecl *MD);
 
 const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM,
                                               CanQualType returnType,
                                               ArrayRef<CanQualType> argTypes,
                                               FunctionType::ExtInfo info,
                                               RequiredArgs args);
 
+const CGFunctionInfo &arrangeCXXConstructorCall(CodeGenModule &CGM,
+                                                ArrayRef<CanQualType> argTypes,
+                                                const CXXConstructorDecl *CD,
+                                                CXXCtorType CtorKind,
+                                                unsigned ExtraPrefixArgs,
+                                                unsigned ExtraSuffixArgs,
+                                                bool PassProtoArgs = true);
+
+const CGFunctionInfo &arrangeCXXMethodCall(CodeGenModule &CGM,
+                                           ArrayRef<CanQualType> argTypes,
+                                           const FunctionProtoType *type,
+                                           RequiredArgs required,
+                                           unsigned numPrefixArgs);
+
 /// Returns null if the function type is incomplete and can't be lowered.
 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
                                             const FunctionDecl *FD);
 
 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

clang/lib/CodeGen/CGCall.cpp

CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args,
                                         unsigned ExtraPrefixArgs,
                                         unsigned ExtraSuffixArgs,
                                         bool PassProtoArgs) {
   // FIXME: Kill copy.
   SmallVector<CanQualType, 16> ArgTypes;
   for (const auto &Arg : args)
     ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
 
+  return arrangeCXXConstructorCall(ArgTypes, D, CtorKind, ExtraPrefixArgs,
+                                   ExtraSuffixArgs, PassProtoArgs);
+}
+
+const CGFunctionInfo &
+CodeGenTypes::arrangeCXXConstructorCall(ArrayRef<CanQualType> ArgTypes,
+                                        const CXXConstructorDecl *D,
+                                        CXXCtorType CtorKind,
+                                        unsigned ExtraPrefixArgs,
+                                        unsigned ExtraSuffixArgs,
+                                        bool PassProtoArgs) {
   // +1 for implicit this, which should always be args[0].
   unsigned TotalPrefixArgs = 1 + ExtraPrefixArgs;
 
   CanQual<FunctionProtoType> FPT = GetFormalType(D);
   RequiredArgs Required = PassProtoArgs
                               ? RequiredArgs::forPrototypePlus(
                                     FPT, TotalPrefixArgs + ExtraSuffixArgs)
                               : RequiredArgs::All;

 ///
 /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It
 /// does not count `this`.
 const CGFunctionInfo &
 CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
                                    const FunctionProtoType *proto,
                                    RequiredArgs required,
                                    unsigned numPrefixArgs) {
-  assert(numPrefixArgs + 1 <= args.size() &&
+  // FIXME: Kill copy.
+  auto argTypes = getArgTypesForCall(Context, args);
+
+  return arrangeCXXMethodCall(argTypes, proto, required, numPrefixArgs);
+}
+
+const CGFunctionInfo &
+CodeGenTypes::arrangeCXXMethodCall(ArrayRef<CanQualType> argTypes,
+                                   const FunctionProtoType *proto,
+                                   RequiredArgs required,
+                                   unsigned numPrefixArgs) {
+  assert(numPrefixArgs + 1 <= argTypes.size() &&
          "Emitting a call with less args than the required prefix?");
   // Add one to account for `this`. It's a bit awkward here, but we don't count
   // `this` in similar places elsewhere.
   auto paramInfos =
-    getExtParameterInfosForCall(proto, numPrefixArgs + 1, args.size());
-
-  // FIXME: Kill copy.
-  auto argTypes = getArgTypesForCall(Context, args);
+    getExtParameterInfosForCall(proto, numPrefixArgs + 1, argTypes.size());
 
   FunctionType::ExtInfo info = proto->getExtInfo();
   return arrangeLLVMFunctionInfo(
       GetReturnType(proto->getReturnType()), /*instanceMethod=*/true,
       /*chainCall=*/false, argTypes, info, paramInfos, required);
 }
 
 const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {

clang/lib/CodeGen/CodeGenABITypes.cpp

CodeGen::arrangeFreeFunctionCall(CodeGenModule &CGM,
                                  ArrayRef<CanQualType> argTypes,
                                  FunctionType::ExtInfo info,
                                  RequiredArgs args) {
   return CGM.getTypes().arrangeLLVMFunctionInfo(
       returnType, /*instanceMethod=*/false, /*chainCall=*/false, argTypes,
       info, {}, args);
 }
 
+const CGFunctionInfo &
+CodeGen::arrangeCXXConstructorCall(CodeGenModule &CGM,
+                                   ArrayRef<CanQualType> argTypes,
+                                   const CXXConstructorDecl *CD,
+                                   CXXCtorType CtorKind,
+                                   unsigned ExtraPrefixArgs,
+                                   unsigned ExtraSuffixArgs,
+                                   bool PassProtoArgs) {
+  return CGM.getTypes().arrangeCXXConstructorCall(
+      argTypes, CD, CtorKind, ExtraPrefixArgs, ExtraSuffixArgs, PassProtoArgs);
+}
+
+const CGFunctionInfo &arrangeCXXMethodCall(CodeGenModule &CGM,
+                                           ArrayRef<CanQualType> argTypes,
+                                           const FunctionProtoType *type,
+                                           RequiredArgs required,
+                                           unsigned numPrefixArgs) {
+  return CGM.getTypes().arrangeCXXMethodCall(argTypes, type, required,
+                                             numPrefixArgs);
+}
+
 llvm::FunctionType *
 CodeGen::convertFreeFunctionType(CodeGenModule &CGM, const FunctionDecl *FD) {
   assert(FD != nullptr && "Expected a non-null function declaration!");
   llvm::Type *T = CGM.getTypes().ConvertType(FD->getType());
 
   if (auto FT = dyn_cast<llvm::FunctionType>(T))
     return FT;
 

clang/lib/CodeGen/CodeGenTypes.h

public:
   const CGFunctionInfo &arrangeCXXMethodDeclaration(const CXXMethodDecl *MD);
   const CGFunctionInfo &arrangeCXXStructorDeclaration(GlobalDecl GD);
   const CGFunctionInfo &arrangeCXXConstructorCall(const CallArgList &Args,
                                                   const CXXConstructorDecl *D,
                                                   CXXCtorType CtorKind,
                                                   unsigned ExtraPrefixArgs,
                                                   unsigned ExtraSuffixArgs,
                                                   bool PassProtoArgs = true);
+  const CGFunctionInfo &
+  arrangeCXXConstructorCall(ArrayRef<CanQualType> ArgTypes,
+                            const CXXConstructorDecl *D,
+                            CXXCtorType CtorKind,
+                            unsigned ExtraPrefixArgs,
+                            unsigned ExtraSuffixArgs,
+                            bool PassProtoArgs = true);
 
   const CGFunctionInfo &arrangeCXXMethodCall(const CallArgList &args,
                                              const FunctionProtoType *type,
                                              RequiredArgs required,
                                              unsigned numPrefixArgs);
+  const CGFunctionInfo &arrangeCXXMethodCall(ArrayRef<CanQualType> argTypes,
+                                             const FunctionProtoType *type,
+                                             RequiredArgs required,
+                                             unsigned numPrefixArgs);
   const CGFunctionInfo &
   arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD);
   const CGFunctionInfo &arrangeMSCtorClosure(const CXXConstructorDecl *CD,
                                                  CXXCtorType CT);
   const CGFunctionInfo &arrangeCXXMethodType(const CXXRecordDecl *RD,
                                              const FunctionProtoType *FTP,
                                              const CXXMethodDecl *MD);