[interop][SwiftToCxx] Add support for emitting resilient struct bindings

Author: hyp

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -18,6 +18,10 @@ using namespace cxx_synthesis;
 
 StringRef cxx_synthesis::getCxxImplNamespaceName() { return "_impl"; }
 
+StringRef cxx_synthesis::getCxxOpaqueStorageClassName() {
+  return "OpaqueStorage";
+}
+
 bool ClangSyntaxPrinter::isClangKeyword(StringRef name) {
   static const llvm::DenseSet<StringRef> keywords = [] {
     llvm::DenseSet<StringRef> set;

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -29,6 +29,10 @@ namespace cxx_synthesis {
 /// module in C++.
 StringRef getCxxImplNamespaceName();
 
+/// Return the name of the C++ class inside of `swift::_impl`
+/// namespace that holds an opaque value, like a resilient struct.
+StringRef getCxxOpaqueStorageClassName();
+
 } // end namespace cxx_synthesis
 
 class ClangSyntaxPrinter {

lib/PrintAsClang/PrintClangFunction.cpp

@@ -51,6 +51,14 @@ bool isKnownType(Type t, PrimitiveTypeMapping &typeMapping,
   return getKnownTypeInfo(typeDecl, typeMapping, languageMode) != None;
 }
 
+bool isResilientType(Type t) {
+  if (auto *typeAliasType = dyn_cast<TypeAliasType>(t.getPointer()))
+    return isResilientType(typeAliasType->getSinglyDesugaredType());
+  else if (auto *nominalType = t->getNominalOrBoundGenericNominal())
+    return nominalType->isResilient();
+  return false;
+}
+
 bool isKnownCxxType(Type t, PrimitiveTypeMapping &typeMapping) {
   return isKnownType(t, typeMapping, OutputLanguageMode::Cxx);
 }
@@ -135,7 +143,8 @@ class CFunctionSignatureTypePrinter
     // FIXME: Handle optional structures.
     if (typeUseKind == FunctionSignatureTypeUse::ParamType) {
       if (languageMode != OutputLanguageMode::Cxx &&
-          interopContext.getIrABIDetails().shouldPassIndirectly(ST)) {
+          (SD->isResilient() ||
+           interopContext.getIrABIDetails().shouldPassIndirectly(ST))) {
         if (modifiersDelegate.prefixIndirectParamValueTypeInC)
           (*modifiersDelegate.prefixIndirectParamValueTypeInC)(os);
         // FIXME: it would be nice to print out the C struct type here.
@@ -198,7 +207,8 @@ void DeclAndTypeClangFunctionPrinter::printFunctionSignature(
   bool isIndirectReturnType =
       kind == FunctionSignatureKind::CFunctionProto &&
       !isKnownCType(resultTy, typeMapping) &&
-      interopContext.getIrABIDetails().shouldReturnIndirectly(resultTy);
+      (isResilientType(resultTy) ||
+       interopContext.getIrABIDetails().shouldReturnIndirectly(resultTy));
   if (!isIndirectReturnType) {
     OptionalTypeKind retKind;
     Type objTy;
@@ -285,7 +295,8 @@ void DeclAndTypeClangFunctionPrinter::printCxxToCFunctionParameterUse(
     if (auto *structDecl = type->getStructOrBoundGenericStruct()) {
       ClangValueTypePrinter(os, cPrologueOS, typeMapping, interopContext)
           .printParameterCxxToCUseScaffold(
-              interopContext.getIrABIDetails().shouldPassIndirectly(type),
+              structDecl->isResilient() ||
+                  interopContext.getIrABIDetails().shouldPassIndirectly(type),
               structDecl, namePrinter, isInOut,
               /*isSelf=*/paramRole &&
                   *paramRole == AdditionalParam::Role::Self);
@@ -352,6 +363,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
   if (!isKnownCxxType(resultTy, typeMapping)) {
     if (auto *structDecl = resultTy->getStructOrBoundGenericStruct()) {
       bool isIndirect =
+          structDecl->isResilient() ||
           interopContext.getIrABIDetails().shouldReturnIndirectly(resultTy);
       ClangValueTypePrinter valueTypePrinter(os, cPrologueOS, typeMapping,
                                              interopContext);

lib/PrintAsClang/PrintClangValueType.cpp

@@ -76,16 +76,18 @@ void printCTypeMetadataTypeFunction(raw_ostream &os,
 void ClangValueTypePrinter::printValueTypeDecl(
     const NominalTypeDecl *typeDecl,
     llvm::function_ref<void(void)> bodyPrinter) {
-  auto typeSizeAlign =
-      interopContext.getIrABIDetails().getTypeSizeAlignment(typeDecl);
-  if (!typeSizeAlign) {
-    // FIXME: handle non-fixed layout structs.
-    return;
-  }
-  if (typeSizeAlign->size == 0) {
-    // FIXME: How to represent 0 sized structs?
-    return;
+  llvm::Optional<IRABIDetailsProvider::SizeAndAlignment> typeSizeAlign;
+  if (!typeDecl->isResilient()) {
+
+    typeSizeAlign =
+        interopContext.getIrABIDetails().getTypeSizeAlignment(typeDecl);
+    assert(typeSizeAlign && "unknown layout for non-resilient type!");
+    if (typeSizeAlign->size == 0) {
+      // FIXME: How to represent 0 sized structs?
+      return;
+    }
   }
+  bool isOpaqueLayout = !typeSizeAlign.hasValue();
 
   ClangSyntaxPrinter printer(os);
 
@@ -156,23 +158,55 @@ void ClangValueTypePrinter::printValueTypeDecl(
   // Print out private default constructor.
   os << "  inline ";
   printer.printBaseName(typeDecl);
-  os << "() {}\n";
+  if (isOpaqueLayout) {
+    os << "(";
+    printer.printSwiftImplQualifier();
+    os << "ValueWitnessTable *vwTable) : _storage(vwTable) {}\n";
+  } else {
+    os << "() {}\n";
+  }
   // Print out '_make' function which returns an unitialized instance for
   // passing to Swift.
   os << "  static inline ";
   printer.printBaseName(typeDecl);
-  os << " _make() { return ";
-  printer.printBaseName(typeDecl);
-  os << "(); }\n";
+  os << " _make() {";
+  if (isOpaqueLayout) {
+    os << "\n";
+    os << "    auto metadata = " << cxx_synthesis::getCxxImplNamespaceName()
+       << "::";
+    printer.printSwiftTypeMetadataAccessFunctionCall(typeMetadataFuncName);
+    os << ";\n";
+    os << "    return ";
+    printer.printBaseName(typeDecl);
+    os << "(";
+    printer.printValueWitnessTableAccessFromTypeMetadata("metadata");
+    os << ");\n  }\n";
+  } else {
+    os << " return ";
+    printer.printBaseName(typeDecl);
+    os << "(); }\n";
+  }
   // Print out the private accessors to the underlying Swift value storage.
   os << "  inline const char * _Nonnull _getOpaquePointer() const { return "
-        "_storage; }\n";
-  os << "  inline char * _Nonnull _getOpaquePointer() { return _storage; }\n";
+        "_storage";
+  if (isOpaqueLayout)
+    os << ".getOpaquePointer()";
+  os << "; }\n";
+  os << "  inline char * _Nonnull _getOpaquePointer() { return _storage";
+  if (isOpaqueLayout)
+    os << ".getOpaquePointer()";
+  os << "; }\n";
   os << "\n";
 
   // Print out the storage for the value type.
-  os << "  alignas(" << typeSizeAlign->alignment << ") ";
-  os << "char _storage[" << typeSizeAlign->size << "];\n";
+  os << "  ";
+  if (isOpaqueLayout) {
+    printer.printSwiftImplQualifier();
+    os << cxx_synthesis::getCxxOpaqueStorageClassName() << " _storage;\n";
+  } else {
+    os << "alignas(" << typeSizeAlign->alignment << ") ";
+    os << "char _storage[" << typeSizeAlign->size << "];\n";
+  }
   // Wrap up the value type.
   os << "  friend class " << cxx_synthesis::getCxxImplNamespaceName() << "::";
   printCxxImplClassName(os, typeDecl);
@@ -209,7 +243,8 @@ void ClangValueTypePrinter::printValueTypeDecl(
         os << "};\n";
       });
 
-  printCValueTypeStorageStruct(cPrologueOS, typeDecl, *typeSizeAlign);
+  if (!isOpaqueLayout)
+    printCValueTypeStorageStruct(cPrologueOS, typeDecl, *typeSizeAlign);
 }
 
 /// Print the name of the C stub struct for passing/returning a value type

lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp

@@ -118,6 +118,29 @@ static void printTypeMetadataResponseType(SwiftToClangInteropContext &ctx,
                  funcSig.parameterTypes[0]);
 }
 
+static void printSwiftResilientStorageClass(raw_ostream &os) {
+  // FIXME: alignment.
+  auto name = cxx_synthesis::getCxxOpaqueStorageClassName();
+  os << "/// Container for an opaque Swift value, like resilient struct.\n";
+  os << "class " << name << " {\n";
+  os << "public:\n";
+  os << "  inline " << name << "() : storage(nullptr) { }\n";
+  os << "  inline " << name
+     << "(ValueWitnessTable * _Nonnull vwTable) : storage(new "
+        "char[vwTable->size]) { }\n";
+  os << "  inline " << name << "(" << name
+     << "&& other) : storage(other.storage) { other.storage = nullptr; }\n";
+  os << "  inline " << name << "(const " << name << "&) = delete;\n";
+  os << "  inline ~" << name << "() { if (storage) { delete[] storage; } }\n";
+  os << "  inline char * _Nonnull getOpaquePointer() { return static_cast<char "
+        "* _Nonnull>(storage); }\n";
+  os << "  inline const char * _Nonnull getOpaquePointer() const { return "
+        "static_cast<char * _Nonnull>(storage); }\n";
+  os << "private:\n";
+  os << "  char * _Nullable storage;\n";
+  os << "};\n";
+}
+
 void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
                                           PrimitiveTypeMapping &typeMapping,
                                           raw_ostream &os) {
@@ -130,6 +153,8 @@ void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
             os << "\n";
             printValueWitnessTable(os);
           });
+          os << "\n";
+          printSwiftResilientStorageClass(os);
         });
   });
 }

test/Interop/SwiftToCxx/core/swift-impl-defs-in-cxx.swift

@@ -51,6 +51,20 @@
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
 // CHECK-EMPTY:
+// CHECK-NEXT: /// Container for an opaque Swift value, like resilient struct.
+// CHECK-NEXT: class OpaqueStorage {
+// CHECK-NEXT: public:
+// CHECK-NEXT:   inline OpaqueStorage() : storage(nullptr) { }
+// CHECK-NEXT:   inline OpaqueStorage(ValueWitnessTable * _Nonnull vwTable) : storage(new char[vwTable->size]) { }
+// CHECK-NEXT:   inline OpaqueStorage(OpaqueStorage&& other) : storage(other.storage) { other.storage = nullptr; }
+// CHECK-NEXT:   inline OpaqueStorage(const OpaqueStorage&) = delete;
+// CHECK-NEXT:   inline ~OpaqueStorage() { if (storage) { delete[] storage; } }
+// CHECK-NEXT:   inline char * _Nonnull getOpaquePointer() { return static_cast<char * _Nonnull>(storage); }
+// CHECK-NEXT:   inline const char * _Nonnull getOpaquePointer() const { return static_cast<char * _Nonnull>(storage); }
+// CHECK-NEXT: private:
+// CHECK-NEXT:   char * _Nullable storage;
+// CHECK-NEXT: };
+// CHECK-EMPTY:
 // CHECK-NEXT: } // namespace _impl
 // CHECK-EMPTY:
 // CHECK-EMPTY:

test/Interop/SwiftToCxx/structs/resilient-struct-in-cxx-execution.cpp

@@ -0,0 +1,52 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/resilient-struct-in-cxx.swift -enable-library-evolution -typecheck -module-name Structs -clang-header-expose-public-decls -emit-clang-header-path %t/structs.h
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-structs-execution.o
+
+// RUN: %target-interop-build-swift %S/resilient-struct-in-cxx.swift -enable-library-evolution -o %t/swift-structs-execution -Xlinker %t/swift-structs-execution.o -module-name Structs -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+
+// RUN: %target-codesign %t/swift-structs-execution
+// RUN: %target-run %t/swift-structs-execution | %FileCheck --check-prefixes=CHECK,CURRENT %s
+
+// RUN: %target-interop-build-swift %S/resilient-struct-in-cxx.swift -enable-library-evolution -o %t/swift-structs-execution-new -Xlinker %t/swift-structs-execution.o -module-name Structs -Xfrontend -entry-point-function-name -Xfrontend swiftMain -D CHANGE_LAYOUT
+
+// RUN: %target-codesign %t/swift-structs-execution-new
+// RUN: %target-run %t/swift-structs-execution-new | %FileCheck --check-prefixes=CHECK,CHANGE %s
+
+// REQUIRES: executable_test
+
+#include <assert.h>
+#include "structs.h"
+
+int main() {
+  using namespace Structs;
+
+  auto largeStruct = createLargeStruct(11);
+  assert(largeStruct.getX1() == 11);
+  largeStruct.dump();
+// CHECK: x.1 = 11, .2 = -11, .3 = 22, .4 = 7, .5 = 0
+
+  auto smallStruct = largeStruct.getFirstSmallStruct();
+  assert(smallStruct.getX() == 65);
+  smallStruct.dump();
+// CHECK: find - small dump
+// CURRENT-NEXT: x = 65
+// CHANGE-NEXT: x&y = 65&0
+
+  printSmallAndLarge(smallStruct, largeStruct);
+// CHECK: find - small dump
+// CURRENT-NEXT: x = 65
+// CHANGE-NEXT: x&y = 65&0
+// CHECK-NEXT: x.1 = 11, .2 = -11, .3 = 22, .4 = 7, .5 = 0
+
+  {
+    auto structWithRefCountStoredProp =
+      createStructWithRefCountStoredProp();
+    structWithRefCountStoredProp.dump();
+  }
+// CHECK-NEXT: create RefCountedClass 0
+// CHECK-NEXT: storedRef = 0
+// CHECK-NEXT: destroy RefCountedClass 0
+  return 0;
+}