Merge pull request swiftlang#59318 from hyp/eng/struct-interop-pass-return

[interop][SwiftToCxx] pass / return Swift struct values between C/C++…

Author: hyp

include/swift/IRGen/IRABIDetailsProvider.h

@@ -13,13 +13,17 @@
 #ifndef SWIFT_IRGEN_IRABIDETAILSPROVIDER_H
 #define SWIFT_IRGEN_IRABIDETAILSPROVIDER_H
 
+#include "swift/AST/Type.h"
+#include "clang/AST/CharUnits.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include <cstdint>
 #include <memory>
 #include <utility>
 
 namespace swift {
 
+class ASTContext;
 class IRGenOptions;
 class ModuleDecl;
 class NominalTypeDecl;
@@ -45,6 +49,24 @@ class IRABIDetailsProvider {
   llvm::Optional<SizeAndAlignment>
   getTypeSizeAlignment(const NominalTypeDecl *TD);
 
+  /// Returns true if the given type should be passed indirectly into a swiftcc
+  /// function.
+  bool shouldPassIndirectly(Type t);
+
+  /// Returns true if the given type should be returned indirectly from a
+  /// swiftcc function.
+  bool shouldReturnIndirectly(Type t);
+
+  /// Enumerates all of the members of the underlying record in terms of their
+  /// primitive types that needs to be stored in a Clang/LLVM record when this
+  /// type is passed or returned directly to/from swiftcc function.
+  ///
+  /// Returns true if an error occurred when a particular member can't be
+  /// represented with an AST type.
+  bool enumerateDirectPassingRecordMembers(
+      Type t, llvm::function_ref<void(clang::CharUnits, clang::CharUnits, Type)>
+                  callback);
+
 private:
   std::unique_ptr<IRABIDetailsProviderImpl> impl;
 };

lib/IRGen/IRABIDetailsProvider.cpp

@@ -15,15 +15,45 @@
 #include "GenType.h"
 #include "IRGen.h"
 #include "IRGenModule.h"
+#include "NativeConventionSchema.h"
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/SILModule.h"
+#include "clang/CodeGen/ModuleBuilder.h"
+#include "clang/CodeGen/SwiftCallingConv.h"
+#include "llvm/IR/DerivedTypes.h"
 
 using namespace swift;
 using namespace irgen;
 
+static Optional<Type> getPrimitiveTypeFromLLVMType(ASTContext &ctx,
+                                                   const llvm::Type *type) {
+  if (const auto *intType = dyn_cast<llvm::IntegerType>(type)) {
+    switch (intType->getBitWidth()) {
+    case 8:
+      return ctx.getUInt8Type();
+    case 16:
+      return ctx.getUInt16Type();
+    case 32:
+      return ctx.getUInt32Type();
+    case 64:
+      return ctx.getUInt64Type();
+    default:
+      return None;
+    }
+  } else if (type->isFloatTy()) {
+    return ctx.getFloatType();
+  } else if (type->isDoubleTy()) {
+    return ctx.getDoubleType();
+  } else if (type->isPointerTy()) {
+    return ctx.getOpaquePointerType();
+  }
+  // FIXME: Handle vector type.
+  return None;
+}
+
 namespace swift {
 
 class IRABIDetailsProviderImpl {
@@ -44,6 +74,39 @@ class IRABIDetailsProviderImpl {
         fixedTI->getFixedAlignment().getValue()};
   }
 
+  bool shouldPassIndirectly(Type type) {
+    auto *TI = &IGM.getTypeInfoForUnlowered(type);
+    NativeConventionSchema schema(IGM, TI, /*isResult=*/false);
+    return schema.requiresIndirect();
+  }
+
+  bool shouldReturnIndirectly(Type type) {
+    if (type->isVoid())
+      return false;
+    auto *TI = &IGM.getTypeInfoForUnlowered(type);
+    NativeConventionSchema schema(IGM, TI, /*isResult=*/true);
+    return schema.requiresIndirect();
+  }
+
+  bool enumerateDirectPassingRecordMembers(
+      Type t, llvm::function_ref<void(clang::CharUnits, clang::CharUnits, Type)>
+                  callback) {
+    auto *TI = &IGM.getTypeInfoForUnlowered(t);
+    NativeConventionSchema schema(IGM, TI, /*isResult=*/false);
+    bool hasError = false;
+    schema.enumerateComponents(
+        [&](clang::CharUnits offset, clang::CharUnits end, llvm::Type *type) {
+          auto primitiveType = getPrimitiveTypeFromLLVMType(
+              IGM.getSwiftModule()->getASTContext(), type);
+          if (!primitiveType) {
+            hasError = true;
+            return;
+          }
+          callback(offset, end, *primitiveType);
+        });
+    return hasError;
+  }
+
 private:
   Lowering::TypeConverter typeConverter;
   // Default silOptions are sufficient, as we don't need to generated SIL.
@@ -65,3 +128,17 @@ llvm::Optional<IRABIDetailsProvider::SizeAndAlignment>
 IRABIDetailsProvider::getTypeSizeAlignment(const NominalTypeDecl *TD) {
   return impl->getTypeSizeAlignment(TD);
 }
+
+bool IRABIDetailsProvider::shouldPassIndirectly(Type t) {
+  return impl->shouldPassIndirectly(t);
+}
+
+bool IRABIDetailsProvider::shouldReturnIndirectly(Type t) {
+  return impl->shouldReturnIndirectly(t);
+}
+
+bool IRABIDetailsProvider::enumerateDirectPassingRecordMembers(
+    Type t, llvm::function_ref<void(clang::CharUnits, clang::CharUnits, Type)>
+                callback) {
+  return impl->enumerateDirectPassingRecordMembers(t, callback);
+}

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "ClangSyntaxPrinter.h"
+#include "swift/AST/Module.h"
 
 using namespace swift;
 using namespace cxx_synthesis;
@@ -43,6 +44,10 @@ void ClangSyntaxPrinter::printIdentifier(StringRef name) {
     os << '_';
 }
 
+void ClangSyntaxPrinter::printModuleNameCPrefix(const ModuleDecl &mod) {
+  os << mod.getName().str() << '_';
+}
+
 /// Print a C++ namespace declaration with the give name and body.
 void ClangSyntaxPrinter::printNamespace(
     llvm::function_ref<void(raw_ostream &OS)> namePrinter,

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -20,6 +20,8 @@
 
 namespace swift {
 
+class ModuleDecl;
+
 namespace cxx_synthesis {
 
 /// Return the name of the implementation namespace that is used to hide
@@ -37,6 +39,10 @@ class ClangSyntaxPrinter {
   /// trailing underscore.
   void printIdentifier(StringRef name);
 
+  /// Print the C-style prefix for the given module name, that's used for
+  /// C type names inside the module.
+  void printModuleNameCPrefix(const ModuleDecl &mod);
+
   /// Print a C++ namespace declaration with the give name and body.
   void
   printNamespace(llvm::function_ref<void(raw_ostream &OS)> namePrinter,

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -332,7 +332,9 @@ class DeclAndTypePrinter::Implementation
     if (outputLang != OutputLanguageMode::Cxx)
       return;
     // FIXME: Print struct's availability.
-    ClangValueTypePrinter printer(os, owningPrinter.interopContext);
+    ClangValueTypePrinter printer(os, owningPrinter.prologueOS,
+                                  owningPrinter.typeMapping,
+                                  owningPrinter.interopContext);
     printer.printStructDecl(SD);
   }
 
@@ -834,7 +836,9 @@ class DeclAndTypePrinter::Implementation
 
     os << "SWIFT_EXTERN ";
 
-    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
+    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
+                                                owningPrinter.typeMapping,
+                                                owningPrinter.interopContext);
     funcPrinter.printFunctionSignature(
         FD, funcABI.getSymbolName(), resultTy,
         DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CFunctionProto);
@@ -873,7 +877,9 @@ class DeclAndTypePrinter::Implementation
         getForeignResultType(FD, funcTy, asyncConvention, errorConvention);
 
     os << "inline ";
-    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
+    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
+                                                owningPrinter.typeMapping,
+                                                owningPrinter.interopContext);
     funcPrinter.printFunctionSignature(
         FD, FD->getName().getBaseIdentifier().get(), resultTy,
         DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk);
@@ -882,27 +888,8 @@ class DeclAndTypePrinter::Implementation
     printFunctionClangAttributes(FD, funcTy);
     printAvailability(FD);
     os << " {\n";
-    os << "  return " << cxx_synthesis::getCxxImplNamespaceName()
-       << "::" << funcABI.getSymbolName() << '(';
-
-    auto params = FD->getParameters();
-    if (params->size()) {
-      size_t index = 1;
-      interleaveComma(*params, os, [&](const ParamDecl *param) {
-        if (param->isInOut()) {
-          os << "&";
-        }
-
-        if (param->hasName()) {
-          ClangSyntaxPrinter(os).printIdentifier(param->getName().str());
-        } else {
-          os << "_" << index;
-        }
-        ++index;
-      });
-    }
-
-    os << ");\n";
+    funcPrinter.printCxxThunkBody(funcABI.getSymbolName(), resultTy,
+                                  FD->getParameters());
     os << "}\n";
   }
 
@@ -1112,8 +1099,11 @@ class DeclAndTypePrinter::Implementation
     if (outputLang == OutputLanguageMode::Cxx) {
       // Emit the underlying C signature that matches the Swift ABI
       // in the generated C++ implementation prologue for the module.
-      auto funcABI = getModuleProloguePrinter()
+      std::string cFuncDecl;
+      llvm::raw_string_ostream cFuncPrologueOS(cFuncDecl);
+      auto funcABI = Implementation(cFuncPrologueOS, owningPrinter, outputLang)
                          .printSwiftABIFunctionSignatureAsCxxFunction(FD);
+      owningPrinter.prologueOS << cFuncPrologueOS.str();
       printAbstractFunctionAsCxxFunctionThunk(FD, funcABI);
       return;
     }

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -265,6 +265,9 @@ class ModuleWriter {
       forwardDeclare(ED);
     } else if (isa<AbstractTypeParamDecl>(TD)) {
       llvm_unreachable("should not see type params here");
+    } else if (isa<StructDecl>(TD)) {
+      // FIXME: add support here.
+      return;
     } else {
       assert(false && "unknown local type decl");
     }
@@ -668,13 +671,15 @@ void swift::printModuleContentsAsCxx(
     M.ValueDecl::getName().print(os);
     os << " {\n";
     os << "namespace " << cxx_synthesis::getCxxImplNamespaceName() << " {\n";
+    os << "extern \"C\" {\n";
     os << "#endif\n\n";
 
     os << prologueOS.str();
 
     os << "\n#ifdef __cplusplus\n";
     os << "}\n";
     os << "}\n";
+    os << "}\n";
   }
 
   // Construct a C++ namespace for the module.

lib/PrintAsClang/PrintAsClang.cpp

@@ -89,12 +89,14 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
       [&] {
         out << "#include <cstdint>\n"
                "#include <cstddef>\n"
-               "#include <cstdbool>\n";
+               "#include <cstdbool>\n"
+               "#include <cstring>\n";
       },
       [&] {
         out << "#include <stdint.h>\n"
                "#include <stddef.h>\n"
-               "#include <stdbool.h>\n";
+               "#include <stdbool.h>\n"
+               "#include <string.h>\n";
       });
   out << "\n"
          "#if !defined(SWIFT_TYPEDEFS)\n"
@@ -301,6 +303,7 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
     out << "#endif\n";
   };
   emitMacro("SWIFT_CALL", "__attribute__((swiftcall))");
+  emitMacro("SWIFT_INDIRECT_RESULT", "__attribute__((swift_indirect_result))");
   // SWIFT_NOEXCEPT applies 'noexcept' in C++ mode only.
   emitCxxConditional(
       out, [&] { emitMacro("SWIFT_NOEXCEPT", "noexcept"); },