Call arrangeCXXStructorDeclaration to arrange constructor signatures

ahatanaka · ahatanaka · commit 9ddee0f2c8cc · 2024-02-22T07:16:20.000-08:00
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -25,6 +25,7 @@
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILType.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/GlobalDecl.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CodeGenABITypes.h"
@@ -430,7 +431,7 @@ namespace {
     bool forStaticCall = false; // Used for objc_method (direct call or not).
 
     // Indicates this is a c++ constructor call.
-    bool forCXXConstructorCall = false;
+    const clang::CXXConstructorDecl *cxxCtorDecl = nullptr;
 
   public:
     SmallVector<llvm::Type*, 8> ParamIRTypes;
@@ -447,9 +448,9 @@ namespace {
 
     SignatureExpansion(IRGenModule &IGM, CanSILFunctionType fnType,
                        FunctionPointerKind fnKind, bool forStaticCall = false,
-                       bool forCXXConstructorCall = false)
+                       const clang::CXXConstructorDecl *cxxCtorDecl = nullptr)
         : IGM(IGM), FnType(fnType), forStaticCall(forStaticCall),
-          forCXXConstructorCall(forCXXConstructorCall), FnKind(fnKind) {}
+          cxxCtorDecl(cxxCtorDecl), FnKind(fnKind) {}
 
     /// Expand the components of the primary entrypoint of the function type.
     void expandFunctionType(
@@ -1374,12 +1375,8 @@ void SignatureExpansion::expandExternalSignatureTypes() {
             IGM.getSILModule(), FnType, TypeExpansionContext::minimal()));
   }();
 
-  // Convert the SIL result type to a Clang type. If this is for a c++
-  // constructor, use 'void' as the return type.
-  auto clangResultTy = IGM.getClangType(
-      forCXXConstructorCall
-          ? SILType::getPrimitiveObjectType(IGM.Context.TheEmptyTupleType)
-          : SILResultTy);
+  // Convert the SIL result type to a Clang type.
+  auto clangResultTy = IGM.getClangType(SILResultTy);
 
   // Now convert the parameters to Clang types.
   auto params = FnType->getParameters();
@@ -1415,7 +1412,7 @@ void SignatureExpansion::expandExternalSignatureTypes() {
   }
 
   case SILFunctionTypeRepresentation::CFunctionPointer:
-    if (forCXXConstructorCall) {
+    if (cxxCtorDecl) {
       auto clangTy = IGM.getClangASTContext().getPointerType(
           IGM.getClangType(SILResultTy));
       paramTys.push_back(clangTy);
@@ -1447,10 +1444,15 @@ void SignatureExpansion::expandExternalSignatureTypes() {
 
   // Generate function info for this signature.
   auto extInfo = clang::FunctionType::ExtInfo();
-  auto &FI = clang::CodeGen::arrangeFreeFunctionCall(IGM.ClangCodeGen->CGM(),
-                                             clangResultTy, paramTys, extInfo,
-                                             clang::CodeGen::RequiredArgs::All);
-  ForeignInfo.ClangInfo = &FI;
+
+  if (cxxCtorDecl)
+    ForeignInfo.ClangInfo = &clang::CodeGen::arrangeCXXStructorDeclaration(
+        IGM.ClangCodeGen->CGM(), {cxxCtorDecl, clang::Ctor_Complete});
+  else
+    ForeignInfo.ClangInfo = &clang::CodeGen::arrangeFreeFunctionCall(
+        IGM.ClangCodeGen->CGM(), clangResultTy, paramTys, extInfo,
+        clang::CodeGen::RequiredArgs::All);
+  auto &FI = *ForeignInfo.ClangInfo;
 
   assert(FI.arg_size() == paramTys.size() &&
          "Expected one ArgInfo for each parameter type!");
@@ -1461,8 +1463,7 @@ void SignatureExpansion::expandExternalSignatureTypes() {
   bool formalIndirectResult = FnType->getNumResults() > 0 &&
                               FnType->getSingleResult().isFormalIndirect();
   assert(
-      (forCXXConstructorCall || !formalIndirectResult ||
-       returnInfo.isIndirect()) &&
+      (cxxCtorDecl || !formalIndirectResult || returnInfo.isIndirect()) &&
       "swift and clang disagree on whether the result is returned indirectly");
 #endif
 
@@ -2175,10 +2176,10 @@ Signature SignatureExpansion::getSignature() {
 Signature Signature::getUncached(IRGenModule &IGM,
                                  CanSILFunctionType formalType,
                                  FunctionPointerKind fpKind, bool forStaticCall,
-                                 bool forCXXConstructorCall) {
+                                 const clang::CXXConstructorDecl *cxxCtorDecl) {
   GenericContextScope scope(IGM, formalType->getInvocationGenericSignature());
   SignatureExpansion expansion(IGM, formalType, fpKind, forStaticCall,
-                               forCXXConstructorCall);
+                               cxxCtorDecl);
   expansion.expandFunctionType();
   return expansion.getSignature();
 }
@@ -3995,6 +3996,12 @@ static void externalizeArguments(IRGenFunction &IGF, const Callee &callee,
     // swiftcall function pointers through SIL as C functions anyway.
     assert(FI.getExtParameterInfo(i).getABI() == clang::ParameterABI::Ordinary);
 
+    assert((!silConv.isSILIndirect(params[i - firstParam]) ||
+            AI.getKind() == clang::CodeGen::ABIArgInfo::Direct ||
+            AI.getKind() == clang::CodeGen::ABIArgInfo::Indirect) &&
+           "indirect SIL types passed indirectly should be classified as "
+           "either Direct or Indirect");
+
     // Add a padding argument if required.
     if (auto *padType = AI.getPaddingType())
       out.add(llvm::UndefValue::get(padType));
@@ -4046,6 +4053,15 @@ static void externalizeArguments(IRGenFunction &IGF, const Callee &callee,
     case clang::CodeGen::ABIArgInfo::IndirectAliased:
       llvm_unreachable("not implemented");
     case clang::CodeGen::ABIArgInfo::Indirect: {
+      // If this is a SIL type passed indirectly, avoid emitting a redundant
+      // initializing copy.
+      if (silConv.isSILIndirect(params[i - firstParam])) {
+        assert(paramType.isAddress() && "SIL type is not an address?");
+        auto addr = in.claimNext();
+        out.add(addr);
+        break;
+      }
+
       auto &ti = cast<LoadableTypeInfo>(IGF.getTypeInfo(paramType));
 
       auto temp = ti.allocateStack(IGF, paramType, "indirect-temporary");
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -3583,8 +3583,7 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(
     }
 
     if (cxxCtor) {
-      Signature signature = getSignature(f->getLoweredFunctionType(),
-                                         /*isCXXConstructorCall*/ true);
+      Signature signature = getSignature(f->getLoweredFunctionType(), cxxCtor);
 
       // The thunk has private linkage, so it doesn't need to have a predictable
       // mangled name -- we just need to make sure the name is unique.
diff --git a/lib/IRGen/GenFunc.cpp b/lib/IRGen/GenFunc.cpp
@@ -131,7 +131,9 @@ namespace {
     FuncSignatureInfo(CanSILFunctionType formalType)
       : FormalType(formalType) {}
 
-    Signature getCXXConstructorSignature(IRGenModule &IGM) const;
+    Signature
+    getCXXConstructorSignature(const clang::CXXConstructorDecl *cxxCtorDecl,
+                               IRGenModule &IGM) const;
     Signature getSignature(IRGenModule &IGM) const;
   };
 
@@ -676,17 +678,16 @@ Signature FuncSignatureInfo::getSignature(IRGenModule &IGM) const {
   return TheSignature;
 }
 
-Signature
-FuncSignatureInfo::getCXXConstructorSignature(IRGenModule &IGM) const {
+Signature FuncSignatureInfo::getCXXConstructorSignature(
+    const clang::CXXConstructorDecl *cxxCtorDecl, IRGenModule &IGM) const {
   // If it's already been filled in, we're done.
   if (TheCXXConstructorSignature.isValid())
     return TheCXXConstructorSignature;
 
   // Update the cache and return.
   TheCXXConstructorSignature =
       Signature::getUncached(IGM, FormalType, FunctionPointerKind(FormalType),
-                             /*forStaticCall*/ false,
-                             /*forCXXConstructorCall*/ true);
+                             /*forStaticCall*/ false, cxxCtorDecl);
   assert(TheCXXConstructorSignature.isValid());
   return TheCXXConstructorSignature;
 }
@@ -729,16 +730,17 @@ getFuncSignatureInfoForLowered(IRGenModule &IGM, CanSILFunctionType type) {
   llvm_unreachable("bad function type representation");
 }
 
-Signature IRGenModule::getSignature(CanSILFunctionType type,
-                                    bool isCXXConstructorCall) {
+Signature
+IRGenModule::getSignature(CanSILFunctionType type,
+                          const clang::CXXConstructorDecl *cxxCtorDecl) {
   return getSignature(type, FunctionPointerKind(type), /*forStaticCall*/ false,
-                      isCXXConstructorCall);
+                      cxxCtorDecl);
 }
 
-Signature IRGenModule::getSignature(CanSILFunctionType type,
-                                    FunctionPointerKind kind,
-                                    bool forStaticCall,
-                                    bool isCXXConstructorCall) {
+Signature
+IRGenModule::getSignature(CanSILFunctionType type, FunctionPointerKind kind,
+                          bool forStaticCall,
+                          const clang::CXXConstructorDecl *cxxCtorDecl) {
   // Don't bother caching if we're working with a special kind.
   if (kind.isSpecial())
     return Signature::getUncached(*this, type, kind);
@@ -751,8 +753,8 @@ Signature IRGenModule::getSignature(CanSILFunctionType type,
     return objcSigInfo.getDirectSignature(*this);
   }
 
-  if (isCXXConstructorCall)
-    return sigInfo.getCXXConstructorSignature(*this);
+  if (cxxCtorDecl)
+    return sigInfo.getCXXConstructorSignature(cxxCtorDecl, *this);
 
   return sigInfo.getSignature(*this);
 }
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -1574,11 +1574,13 @@ private:                                                                       \
   void finalizeClangCodeGen();
   void finishEmitAfterTopLevel();
 
-  Signature getSignature(CanSILFunctionType fnType,
-                         bool isCXXConstructorCall = false);
-  Signature getSignature(CanSILFunctionType fnType, FunctionPointerKind kind,
-                         bool forStaticCall = false,
-                         bool isCXXConstructorCall = false);
+  Signature
+  getSignature(CanSILFunctionType fnType,
+               const clang::CXXConstructorDecl *cxxCtorDecl = nullptr);
+  Signature
+  getSignature(CanSILFunctionType fnType, FunctionPointerKind kind,
+               bool forStaticCall = false,
+               const clang::CXXConstructorDecl *cxxCtorDecl = nullptr);
   llvm::FunctionType *getFunctionType(CanSILFunctionType type,
                                       llvm::AttributeList &attrs,
                                       ForeignFunctionInfo *foreignInfo=nullptr);
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -2969,13 +2969,13 @@ void IRGenSILFunction::visitFunctionRefBaseInst(FunctionRefBaseInst *i) {
   auto fnType = fn->getLoweredFunctionType();
 
   auto fpKind = irgen::classifyFunctionPointerKind(fn);
-  bool isCXXConstructor = false;
+  const clang::CXXConstructorDecl *cxxCtorDecl = nullptr;
 
   if (auto *clangFnDecl = fn->getClangDecl())
-    isCXXConstructor = isa<clang::CXXConstructorDecl>(clangFnDecl);
+    cxxCtorDecl = dyn_cast<clang::CXXConstructorDecl>(clangFnDecl);
 
-  auto sig = IGM.getSignature(fnType, fpKind, true /*forStaticCall*/,
-                              isCXXConstructor);
+  auto sig =
+      IGM.getSignature(fnType, fpKind, true /*forStaticCall*/, cxxCtorDecl);
 
   // Note that the pointer value returned by getAddrOfSILFunction doesn't
   // necessarily have element type sig.getType(), e.g. if it's imported.
diff --git a/lib/IRGen/Signature.h b/lib/IRGen/Signature.h
@@ -31,6 +31,7 @@ namespace llvm {
 }
 
 namespace clang {
+  class CXXConstructorDecl;
   namespace CodeGen {
     class CGFunctionInfo;    
   }
@@ -202,10 +203,10 @@ class Signature {
   /// This is a private detail of the implementation of
   /// IRGenModule::getSignature(CanSILFunctionType), which is what
   /// clients should generally be using.
-  static Signature getUncached(IRGenModule &IGM, CanSILFunctionType formalType,
-                               FunctionPointerKind kind,
-                               bool forStaticCall = false,
-                               bool forCXXConstructorCall = false);
+  static Signature
+  getUncached(IRGenModule &IGM, CanSILFunctionType formalType,
+              FunctionPointerKind kind, bool forStaticCall = false,
+              const clang::CXXConstructorDecl *cxxCtorDecl = nullptr);
 
   static SignatureExpansionABIDetails
   getUncachedABIDetails(IRGenModule &IGM, CanSILFunctionType formalType,

Original file line number	Diff line number	Diff line change
`@@ -3583,8 +3583,7 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(`
`3583`	`3583`	`}`
`3584`	`3584`
`3585`	`3585`	`if (cxxCtor) {`
`3586`		`- Signature signature = getSignature(f->getLoweredFunctionType(),`
`3587`		`- /isCXXConstructorCall/ true);`
	`3586`	`+ Signature signature = getSignature(f->getLoweredFunctionType(), cxxCtor);`
`3588`	`3587`
`3589`	`3588`	`// The thunk has private linkage, so it doesn't need to have a predictable`
`3590`	`3589`	`// mangled name -- we just need to make sure the name is unique.`