[interop][SwiftToCxx] initial generic function support: pass generic parameters

Only primitive types are supported at the moment from C++ as the type traits aren't emitted for all types yet

Author: hyp

include/swift/IRGen/IRABIDetailsProvider.h

@@ -14,6 +14,7 @@
 #define SWIFT_IRGEN_IRABIDETAILSPROVIDER_H
 
 #include "swift/AST/Decl.h"
+#include "swift/AST/GenericRequirement.h"
 #include "swift/AST/Type.h"
 #include "clang/AST/CharUnits.h"
 #include "llvm/ADT/MapVector.h"
@@ -49,14 +50,13 @@ class IRABIDetailsProvider {
 
   /// Information about any ABI additional parameters.
   struct ABIAdditionalParam {
-    enum class ABIParameterRole { Self, Error };
+    enum class ABIParameterRole { GenericRequirementRole, Self, Error };
 
     ABIParameterRole role;
+    llvm::Optional<GenericRequirement> genericRequirement;
     TypeDecl *type;
   };
 
-  SmallVector<ABIAdditionalParam, 1> ABIAdditionalParams;
-
   /// Returns the size and alignment for the given type, or \c None if the type
   /// is not a fixed layout type.
   llvm::Optional<SizeAndAlignment>

lib/IRGen/GenCall.cpp

@@ -396,11 +396,14 @@ namespace {
     unsigned AsyncContextIdx;
     unsigned AsyncResumeFunctionSwiftSelfIdx = 0;
     FunctionPointerKind FnKind;
+    bool ShouldComputeABIDetails;
+    SmallVector<GenericRequirement, 4> GenericRequirements;
 
     SignatureExpansion(IRGenModule &IGM, CanSILFunctionType fnType,
-                       FunctionPointerKind fnKind)
-        : IGM(IGM), FnType(fnType), FnKind(fnKind) {
-    }
+                       FunctionPointerKind fnKind,
+                       bool ShouldComputeABIDetails = false)
+        : IGM(IGM), FnType(fnType), FnKind(fnKind),
+          ShouldComputeABIDetails(ShouldComputeABIDetails) {}
 
     /// Expand the components of the primary entrypoint of the function type.
     void expandFunctionType();
@@ -1628,7 +1631,9 @@ void SignatureExpansion::expandParameters() {
   // Next, the generic signature.
   if (hasPolymorphicParameters(FnType) &&
       !FnKind.shouldSuppressPolymorphicArguments())
-    expandPolymorphicSignature(IGM, FnType, ParamIRTypes);
+    expandPolymorphicSignature(IGM, FnType, ParamIRTypes,
+                               ShouldComputeABIDetails ? &GenericRequirements
+                                                       : nullptr);
 
   // Certain special functions are passed the continuation directly.
   if (FnKind.shouldPassContinuationDirectly()) {
@@ -1925,14 +1930,19 @@ Signature SignatureExpansion::getSignature() {
   } else {
     result.ExtraDataKind = ExtraData::kindForMember<void>();
   }
+  if (ShouldComputeABIDetails)
+    result.ABIDetails =
+        SignatureExpansionABIDetails{std::move(GenericRequirements)};
   return result;
 }
 
 Signature Signature::getUncached(IRGenModule &IGM,
                                  CanSILFunctionType formalType,
-                                 FunctionPointerKind fpKind) {
+                                 FunctionPointerKind fpKind,
+                                 bool shouldComputeABIDetails) {
   GenericContextScope scope(IGM, formalType->getInvocationGenericSignature());
-  SignatureExpansion expansion(IGM, formalType, fpKind);
+  SignatureExpansion expansion(IGM, formalType, fpKind,
+                               shouldComputeABIDetails);
   expansion.expandFunctionType();
   return expansion.getSignature();
 }

lib/IRGen/GenProto.cpp

@@ -3459,11 +3459,14 @@ namespace {
     ExpandPolymorphicSignature(IRGenModule &IGM, CanSILFunctionType fn)
       : PolymorphicConvention(IGM, fn) {}
 
-    void expand(SmallVectorImpl<llvm::Type*> &out) {
+    void expand(SmallVectorImpl<llvm::Type *> &out,
+                SmallVectorImpl<GenericRequirement> *reqs) {
       for (auto &source : getSources())
         addEarlySource(source, out);
 
       enumerateUnfulfilledRequirements([&](GenericRequirement reqt) {
+        if (reqs)
+          reqs->push_back(reqt);
         out.push_back(reqt.Protocol ? IGM.WitnessTablePtrTy
                                     : IGM.TypeMetadataPtrTy);
       });
@@ -3490,10 +3493,11 @@ namespace {
 } // end anonymous namespace
 
 /// Given a generic signature, add the argument types required in order to call it.
-void irgen::expandPolymorphicSignature(IRGenModule &IGM,
-                                       CanSILFunctionType polyFn,
-                                       SmallVectorImpl<llvm::Type*> &out) {
-  ExpandPolymorphicSignature(IGM, polyFn).expand(out);
+void irgen::expandPolymorphicSignature(
+    IRGenModule &IGM, CanSILFunctionType polyFn,
+    SmallVectorImpl<llvm::Type *> &out,
+    SmallVectorImpl<GenericRequirement> *outReqs) {
+  ExpandPolymorphicSignature(IGM, polyFn).expand(out, outReqs);
 }
 
 void irgen::expandTrailingWitnessSignature(IRGenModule &IGM,

lib/IRGen/GenProto.h

@@ -99,9 +99,10 @@ namespace irgen {
 
   /// Add the witness parameters necessary for calling a function with
   /// the given generics clause.
-  void expandPolymorphicSignature(IRGenModule &IGM,
-                                  CanSILFunctionType type,
-                                  SmallVectorImpl<llvm::Type*> &types);
+  void expandPolymorphicSignature(
+      IRGenModule &IGM, CanSILFunctionType type,
+      SmallVectorImpl<llvm::Type *> &types,
+      SmallVectorImpl<GenericRequirement> *outReqs = nullptr);
 
   /// Return the number of trailing arguments necessary for calling a
   /// witness method.

lib/IRGen/IRABIDetailsProvider.cpp

@@ -148,17 +148,24 @@ class IRABIDetailsProviderImpl {
     auto silFuncType = function->getLoweredFunctionType();
     auto funcPointerKind =
         FunctionPointerKind(FunctionPointerKind::BasicKind::Function);
-    auto signature = Signature::getUncached(IGM, silFuncType, funcPointerKind);
 
+    auto signature = Signature::getUncached(IGM, silFuncType, funcPointerKind,
+                                            /*shouldComputeABIDetail=*/true);
+
+    for (const auto &reqt : signature.getABIDetails().GenericRequirements) {
+      params.push_back({IRABIDetailsProvider::ABIAdditionalParam::
+                            ABIParameterRole::GenericRequirementRole,
+                        reqt, typeConverter.Context.getOpaquePointerDecl()});
+    }
     for (auto attrSet : signature.getAttributes()) {
       if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftSelf))
         params.push_back(
             {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self,
-             typeConverter.Context.getOpaquePointerDecl()});
+             llvm::None, typeConverter.Context.getOpaquePointerDecl()});
       if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftError))
         params.push_back(
             {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Error,
-             typeConverter.Context.getOpaquePointerDecl()});
+             llvm::None, typeConverter.Context.getOpaquePointerDecl()});
     }
     return params;
   }

lib/IRGen/Signature.h

@@ -18,10 +18,12 @@
 #ifndef SWIFT_IRGEN_SIGNATURE_H
 #define SWIFT_IRGEN_SIGNATURE_H
 
-#include "llvm/IR/Attributes.h"
-#include "llvm/IR/CallingConv.h"
+#include "swift/AST/GenericRequirement.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/ExternalUnion.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/CallingConv.h"
 
 namespace llvm {
   class FunctionType;
@@ -94,6 +96,12 @@ class AsyncInfo {
   uint32_t AsyncResumeFunctionSwiftSelfIdx = 0;
 };
 
+/// Recorded information about the specific ABI details.
+struct SignatureExpansionABIDetails {
+  /// Generic requirements added to the signature during expansion.
+  llvm::SmallVector<GenericRequirement, 2> GenericRequirements;
+};
+
 /// A signature represents something which can actually be called.
 class Signature {
   using ExtraData =
@@ -104,6 +112,7 @@ class Signature {
   llvm::CallingConv::ID CallingConv;
   ExtraData::Kind ExtraDataKind; // packed with above
   ExtraData ExtraDataStorage;
+  llvm::Optional<SignatureExpansionABIDetails> ABIDetails;
   static_assert(ExtraData::union_is_trivially_copyable,
                 "not trivially copyable");
 
@@ -126,7 +135,8 @@ class Signature {
   /// IRGenModule::getSignature(CanSILFunctionType), which is what
   /// clients should generally be using.
   static Signature getUncached(IRGenModule &IGM, CanSILFunctionType formalType,
-                               FunctionPointerKind kind);
+                               FunctionPointerKind kind,
+                               bool shouldComputeABIDetails = false);
 
   /// Compute the signature of a coroutine's continuation function.
   static Signature forCoroutineContinuation(IRGenModule &IGM,
@@ -194,6 +204,11 @@ class Signature {
     assert(isValid());
     return Attributes;
   }
+
+  const SignatureExpansionABIDetails &getABIDetails() {
+    assert(ABIDetails.hasValue());
+    return *ABIDetails;
+  }
 };
 
 } // end namespace irgen

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -608,7 +608,7 @@ class DeclAndTypePrinter::Implementation
   }
 
   Type getForeignResultType(AbstractFunctionDecl *AFD,
-                            FunctionType *methodTy,
+                            AnyFunctionType *methodTy,
                             Optional<ForeignAsyncConvention> asyncConvention,
                             Optional<ForeignErrorConvention> errorConvention) {
     // A foreign error convention can affect the result type as seen in
@@ -950,7 +950,7 @@ class DeclAndTypePrinter::Implementation
   }
 
   /// Print C or C++ trailing attributes for a function declaration.
-  void printFunctionClangAttributes(FuncDecl *FD, FunctionType *funcTy) {
+  void printFunctionClangAttributes(FuncDecl *FD, AnyFunctionType *funcTy) {
     if (funcTy->getResult()->isUninhabited()) {
       os << " SWIFT_NORETURN";
     } else if (!funcTy->getResult()->isVoid() &&
@@ -1010,15 +1010,21 @@ class DeclAndTypePrinter::Implementation
       llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
           &params) {
     for (auto param : ABIparams) {
-      if (param.role ==
-          IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self)
+      if (param.role == IRABIDetailsProvider::ABIAdditionalParam::
+                            ABIParameterRole::GenericRequirementRole)
+        params.push_back({DeclAndTypeClangFunctionPrinter::AdditionalParam::
+                              Role::GenericRequirement,
+                          resultTy->getASTContext().getOpaquePointerType(),
+                          /*isIndirect=*/false, param.genericRequirement});
+      else if (param.role ==
+               IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self)
         params.push_back(
             {DeclAndTypeClangFunctionPrinter::AdditionalParam::Role::Self,
              resultTy->getASTContext().getOpaquePointerType(),
              /*isIndirect=*/
              isa<FuncDecl>(FD) ? cast<FuncDecl>(FD)->isMutating() : false});
-      if (param.role ==
-          IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Error)
+      else if (param.role == IRABIDetailsProvider::ABIAdditionalParam::
+                                 ABIParameterRole::Error)
         params.push_back(
             {DeclAndTypeClangFunctionPrinter::AdditionalParam::Role::Error,
              resultTy->getASTContext().getOpaquePointerType()});
@@ -1034,12 +1040,15 @@ class DeclAndTypePrinter::Implementation
         FD->getForeignAsyncConvention();
     Optional<ForeignErrorConvention> errorConvention =
         FD->getForeignErrorConvention();
-    assert(!FD->getGenericSignature() &&
-           "top-level generic functions not supported here");
     // FIXME (Alex): Make type adjustments for C++.
-    auto funcTy = givenFuncType
-                      ? *givenFuncType
-                      : FD->getInterfaceType()->castTo<FunctionType>();
+    AnyFunctionType *funcTy;
+    if (givenFuncType || FD->getInterfaceType()->is<FunctionType>()) {
+      funcTy = givenFuncType ? *givenFuncType
+                             : FD->getInterfaceType()->castTo<FunctionType>();
+    } else {
+      funcTy = FD->getInterfaceType()->castTo<GenericFunctionType>();
+    }
+
     auto resultTy =
         getForeignResultType(FD, funcTy, asyncConvention, errorConvention);
 
@@ -1061,7 +1070,8 @@ class DeclAndTypePrinter::Implementation
            /*isIndirect=*/
            isa<FuncDecl>(FD) ? cast<FuncDecl>(FD)->isMutating() : false});
     }
-    if (funcTy->isThrowing() && !ABIparams.empty())
+    // FIXME: Fix the method 'self' parameter.
+    if (!selfTypeDeclContext && !ABIparams.empty())
       convertABIAdditionalParams(FD, resultTy, ABIparams, additionalParams);
 
     funcPrinter.printFunctionSignature(
@@ -1098,26 +1108,25 @@ class DeclAndTypePrinter::Implementation
         FD->getForeignAsyncConvention();
     Optional<ForeignErrorConvention> errorConvention =
         FD->getForeignErrorConvention();
-    assert(!FD->getGenericSignature() &&
-           "top-level generic functions not supported here");
-    auto funcTy = FD->getInterfaceType()->castTo<FunctionType>();
+    auto funcTy = FD->getInterfaceType()->castTo<AnyFunctionType>();
     auto resultTy =
         getForeignResultType(FD, funcTy, asyncConvention, errorConvention);
 
-    os << "inline ";
     DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
                                                 owningPrinter.typeMapping,
                                                 owningPrinter.interopContext);
     llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
         additionalParams;
     auto ABIparams = owningPrinter.interopContext.getIrABIDetails()
                          .getFunctionABIAdditionalParams(FD);
-    if (funcTy->isThrowing() && !ABIparams.empty())
+    if (!ABIparams.empty())
       convertABIAdditionalParams(FD, resultTy, ABIparams, additionalParams);
-
+    DeclAndTypeClangFunctionPrinter::FunctionSignatureModifiers modifiers;
+    modifiers.isInline = true;
     funcPrinter.printFunctionSignature(
         FD, FD->getName().getBaseIdentifier().get(), resultTy,
-        DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk);
+        DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk,
+        {}, modifiers);
     // FIXME: Support throwing exceptions for Swift errors.
     if (!funcTy->isThrowing())
       os << " noexcept";
@@ -1126,7 +1135,7 @@ class DeclAndTypePrinter::Implementation
     os << " {\n";
     funcPrinter.printCxxThunkBody(
         funcABI.getSymbolName(), FD->getModuleContext(), resultTy,
-        FD->getParameters(), additionalParams, funcTy->isThrowing());
+        FD->getParameters(), additionalParams, funcTy->isThrowing(), funcTy);
     os << "}\n";
   }
 

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -677,7 +677,8 @@ void swift::printModuleContentsAsCxx(
 
   os << "#ifndef SWIFT_PRINTED_CORE\n";
   os << "#define SWIFT_PRINTED_CORE\n";
-  printSwiftToClangCoreScaffold(interopContext, writer.getTypeMapping(), os);
+  printSwiftToClangCoreScaffold(interopContext, M.getASTContext(),
+                                writer.getTypeMapping(), os);
   os << "#endif\n";
 
   // FIXME: refactor.

lib/PrintAsClang/PrintAsClang.cpp

@@ -322,6 +322,15 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
   emitMacro("SWIFT_INDIRECT_RESULT", "__attribute__((swift_indirect_result))");
   emitMacro("SWIFT_CONTEXT", "__attribute__((swift_context))");
   emitMacro("SWIFT_ERROR_RESULT", "__attribute__((swift_error_result))");
+  if (ctx.getStdlibModule()->isStaticLibrary()) {
+    emitMacro("SWIFT_IMPORT_STDLIB_SYMBOL");
+  } else {
+    out << "#if defined(_WIN32)\n";
+    emitMacro("SWIFT_IMPORT_STDLIB_SYMBOL", "__declspec(dllimport)");
+    out << "#else\n";
+    emitMacro("SWIFT_IMPORT_STDLIB_SYMBOL");
+    out << "#endif\n";
+  }
   // SWIFT_NOEXCEPT applies 'noexcept' in C++ mode only.
   emitCxxConditional(
       out, [&] { emitMacro("SWIFT_NOEXCEPT", "noexcept"); },