Merge pull request #59419 from apple/eng/copy-destroy-swift-value-in-cxx

hyp · web-flow · commit 4d0d4afcbc79 · 2022-06-14T12:05:24.000-07:00
[interop][SwiftToCxx] destroy and initWithCopy Swift structs in C++
diff --git a/lib/PrintAsClang/ClangSyntaxPrinter.cpp b/lib/PrintAsClang/ClangSyntaxPrinter.cpp
@@ -127,3 +127,15 @@ void ClangSyntaxPrinter::printNullability(
   if (printKind != NullabilityPrintKind::After)
     os << ' ';
 }
+
+void ClangSyntaxPrinter::printSwiftTypeMetadataAccessFunctionCall(
+    StringRef name) {
+  os << name << "(0)";
+}
+
+void ClangSyntaxPrinter::printValueWitnessTableAccessFromTypeMetadata(
+    StringRef metadataVariable) {
+  os << "*(reinterpret_cast<";
+  printSwiftImplQualifier();
+  os << "ValueWitnessTable **>(" << metadataVariable << "._0) - 1)";
+}
diff --git a/lib/PrintAsClang/ClangSyntaxPrinter.h b/lib/PrintAsClang/ClangSyntaxPrinter.h
@@ -77,6 +77,13 @@ class ClangSyntaxPrinter {
   static bool isClangKeyword(StringRef name);
   static bool isClangKeyword(Identifier name);
 
+  /// Print the call expression to the Swift type metadata access function.
+  void printSwiftTypeMetadataAccessFunctionCall(StringRef name);
+
+  /// Print the expression to access the value witness table pointer from the
+  /// given type metadata variable.
+  void printValueWitnessTableAccessFromTypeMetadata(StringRef metadataVariable);
+
 protected:
   raw_ostream &os;
 };
diff --git a/lib/PrintAsClang/PrintAsClang.cpp b/lib/PrintAsClang/PrintAsClang.cpp
@@ -51,6 +51,18 @@ static void emitObjCConditional(raw_ostream &out,
   out << "#endif\n";
 }
 
+static void writePtrauthPrologue(raw_ostream &os) {
+  emitCxxConditional(os, [&]() {
+    os << "#if __has_include(<ptrauth.h>)\n";
+    os << "# include <ptrauth.h>\n";
+    os << "#else\n";
+    os << "# ifndef __ptrauth_swift_value_witness_function_pointer\n";
+    os << "#  define __ptrauth_swift_value_witness_function_pointer(x)\n";
+    os << "# endif\n";
+    os << "#endif\n";
+  });
+}
+
 static void writePrologue(raw_ostream &out, ASTContext &ctx,
                           StringRef macroGuard) {
 
@@ -98,6 +110,7 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
                "#include <stdbool.h>\n"
                "#include <string.h>\n";
       });
+  writePtrauthPrologue(out);
   out << "\n"
          "#if !defined(SWIFT_TYPEDEFS)\n"
          "# define SWIFT_TYPEDEFS 1\n"
diff --git a/lib/PrintAsClang/PrintClangValueType.cpp b/lib/PrintAsClang/PrintClangValueType.cpp
@@ -61,16 +61,13 @@ printCValueTypeStorageStruct(raw_ostream &os, const NominalTypeDecl *typeDecl,
 }
 
 void printCTypeMetadataTypeFunction(raw_ostream &os,
-                                    const NominalTypeDecl *typeDecl) {
+                                    const NominalTypeDecl *typeDecl,
+                                    StringRef typeMetadataFuncName) {
   os << "// Type metadata accessor for " << typeDecl->getNameStr() << "\n";
-  auto entity = irgen::LinkEntity::forTypeMetadataAccessFunction(
-      typeDecl->getDeclaredType()->getCanonicalType());
   os << "SWIFT_EXTERN ";
   ClangSyntaxPrinter printer(os);
   printer.printSwiftImplQualifier();
-  os << "MetadataResponseTy ";
-  entity.mangle(os);
-  os << '(';
+  os << "MetadataResponseTy " << typeMetadataFuncName << '(';
   printer.printSwiftImplQualifier();
   os << "MetadataRequestTy)";
   os << " SWIFT_NOEXCEPT SWIFT_CALL;\n\n";
@@ -90,6 +87,10 @@ void ClangValueTypePrinter::printStructDecl(const StructDecl *SD) {
 
   ClangSyntaxPrinter printer(os);
 
+  auto typeMetadataFunc = irgen::LinkEntity::forTypeMetadataAccessFunction(
+      SD->getDeclaredType()->getCanonicalType());
+  std::string typeMetadataFuncName = typeMetadataFunc.mangleAsString();
+
   // Print out a forward declaration of the "hidden" _impl class.
   printer.printNamespace(cxx_synthesis::getCxxImplNamespaceName(),
                          [&](raw_ostream &os) {
@@ -99,13 +100,53 @@ void ClangValueTypePrinter::printStructDecl(const StructDecl *SD) {
 
                            // Print out special functions, like functions that
                            // access type metadata.
-                           printCTypeMetadataTypeFunction(os, SD);
+                           printCTypeMetadataTypeFunction(os, SD,
+                                                          typeMetadataFuncName);
                          });
 
   // Print out the C++ class itself.
   os << "class ";
   ClangSyntaxPrinter(os).printBaseName(SD);
   os << " final {\n";
+  os << "public:\n";
+
+  // Print out the destructor.
+  os << "  inline ~";
+  printer.printBaseName(SD);
+  os << "() {\n";
+  os << "    auto metadata = " << cxx_synthesis::getCxxImplNamespaceName()
+     << "::";
+  printer.printSwiftTypeMetadataAccessFunctionCall(typeMetadataFuncName);
+  os << ";\n";
+  os << "    auto *vwTable = ";
+  printer.printValueWitnessTableAccessFromTypeMetadata("metadata");
+  os << ";\n";
+  os << "    vwTable->destroy(_getOpaquePointer(), metadata._0);\n";
+  os << "  }\n";
+
+  os << "  inline ";
+  printer.printBaseName(SD);
+  os << "(const ";
+  printer.printBaseName(SD);
+  os << " &other) {\n";
+  os << "    auto metadata = " << cxx_synthesis::getCxxImplNamespaceName()
+     << "::";
+  printer.printSwiftTypeMetadataAccessFunctionCall(typeMetadataFuncName);
+  os << ";\n";
+  os << "    auto *vwTable = ";
+  printer.printValueWitnessTableAccessFromTypeMetadata("metadata");
+  os << ";\n";
+  os << "    vwTable->initializeWithCopy(_getOpaquePointer(), const_cast<char "
+        "*>(other._getOpaquePointer()), metadata._0);\n";
+  os << "  }\n";
+
+  // FIXME: the move constructor should be hidden somehow.
+  os << "  inline ";
+  printer.printBaseName(SD);
+  os << "(";
+  printer.printBaseName(SD);
+  os << " &&) = default;\n";
+
   // FIXME: Print the other members of the struct.
   os << "private:\n";
 
diff --git a/lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp b/lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp
@@ -14,9 +14,11 @@
 #include "ClangSyntaxPrinter.h"
 #include "PrimitiveTypeMapping.h"
 #include "SwiftToClangInteropContext.h"
+#include "swift/ABI/MetadataValues.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Type.h"
 #include "swift/IRGen/IRABIDetailsProvider.h"
+#include "llvm/ADT/STLExtras.h"
 
 using namespace swift;
 
@@ -60,6 +62,49 @@ static void printKnownType(
   printKnownStruct(typeMapping, os, name, typeRecord);
 }
 
+static void printValueWitnessTableFunctionType(raw_ostream &os, StringRef name,
+                                               StringRef returnType,
+                                               std::string paramTypes,
+                                               uint16_t ptrauthDisc) {
+  os << "using ValueWitness" << name << "Ty = " << returnType << "(*)("
+     << paramTypes << ") __ptrauth_swift_value_witness_function_pointer("
+     << ptrauthDisc << ");\n";
+}
+
+static std::string makeParams(const char *arg) { return arg; }
+
+template <class... T>
+static std::string makeParams(const char *arg, const T... args) {
+  return std::string(arg) + ", " + makeParams(args...);
+}
+
+static void printValueWitnessTable(raw_ostream &os) {
+  std::string members;
+  llvm::raw_string_ostream membersOS(members);
+
+#define WANT_ONLY_REQUIRED_VALUE_WITNESSES
+#define DATA_VALUE_WITNESS(lowerId, upperId, type)                             \
+  membersOS << "  " << type << " " << #lowerId << ";\n";
+#define FUNCTION_VALUE_WITNESS(lowerId, upperId, returnType, paramTypes)       \
+  printValueWitnessTableFunctionType(                                          \
+      os, #upperId, returnType, makeParams paramTypes,                         \
+      SpecialPointerAuthDiscriminators::upperId);                              \
+  membersOS << "  ValueWitness" << #upperId << "Ty _Nonnull " << #lowerId      \
+            << ";\n";
+#define MUTABLE_VALUE_TYPE "void * _Nonnull"
+#define IMMUTABLE_VALUE_TYPE "const void * _Nonnull"
+#define MUTABLE_BUFFER_TYPE "void * _Nonnull"
+#define IMMUTABLE_BUFFER_TYPE "const void * _Nonnull"
+#define TYPE_TYPE "void * _Nonnull"
+#define SIZE_TYPE "size_t"
+#define INT_TYPE "int"
+#define UINT_TYPE "unsigned"
+#define VOID_TYPE "void"
+#include "swift/ABI/ValueWitness.def"
+
+  os << "\nstruct ValueWitnessTable {\n" << membersOS.str() << "};\n";
+}
+
 static void printTypeMetadataResponseType(SwiftToClangInteropContext &ctx,
                                           PrimitiveTypeMapping &typeMapping,
                                           raw_ostream &os) {
@@ -82,6 +127,8 @@ void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
         cxx_synthesis::getCxxImplNamespaceName(), [&](raw_ostream &) {
           printer.printExternC([&](raw_ostream &os) {
             printTypeMetadataResponseType(ctx, typeMapping, os);
+            os << "\n";
+            printValueWitnessTable(os);
           });
         });
   });
diff --git a/test/Interop/SwiftToCxx/core/swift-impl-defs-in-cxx.swift b/test/Interop/SwiftToCxx/core/swift-impl-defs-in-cxx.swift
@@ -23,6 +23,30 @@
 // CHECK-NEXT: // Swift type metadata request type.
 // CHECK-NEXT: typedef uint{{.*}}_t MetadataRequestTy;
 // CHECK-EMPTY:
+// CHECK-NEXT: using ValueWitnessInitializeBufferWithCopyOfBufferTy = void * _Nonnull(*)(void * _Nonnull, void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessDestroyTy = void(*)(void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessInitializeWithCopyTy = void * _Nonnull(*)(void * _Nonnull, void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessAssignWithCopyTy = void * _Nonnull(*)(void * _Nonnull, void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessInitializeWithTakeTy = void * _Nonnull(*)(void * _Nonnull, void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessAssignWithTakeTy = void * _Nonnull(*)(void * _Nonnull, void * _Nonnull, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessGetEnumTagSinglePayloadTy = unsigned(*)(const void * _Nonnull, unsigned, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-NEXT: using ValueWitnessStoreEnumTagSinglePayloadTy = void(*)(void * _Nonnull, unsigned, unsigned, void * _Nonnull) __ptrauth_swift_value_witness_function_pointer(
+// CHECK-EMPTY:
+// CHECK-NEXT: struct ValueWitnessTable {
+// CHECK-NEXT:  ValueWitnessInitializeBufferWithCopyOfBufferTy _Nonnull initializeBufferWithCopyOfBuffer;
+// CHECK-NEXT:  ValueWitnessDestroyTy _Nonnull destroy;
+// CHECK-NEXT:  ValueWitnessInitializeWithCopyTy _Nonnull initializeWithCopy;
+// CHECK-NEXT:  ValueWitnessAssignWithCopyTy _Nonnull assignWithCopy;
+// CHECK-NEXT:  ValueWitnessInitializeWithTakeTy _Nonnull initializeWithTake;
+// CHECK-NEXT:  ValueWitnessAssignWithTakeTy _Nonnull assignWithTake;
+// CHECK-NEXT:  ValueWitnessGetEnumTagSinglePayloadTy _Nonnull getEnumTagSinglePayload;
+// CHECK-NEXT:  ValueWitnessStoreEnumTagSinglePayloadTy _Nonnull storeEnumTagSinglePayload;
+// CHECK-NEXT:  size_t size;
+// CHECK-NEXT:  size_t stride;
+// CHECK-NEXT:  unsigned flags;
+// CHECK-NEXT:  unsigned extraInhabitantCount;
+// CHECK-NEXT: };
+// CHECK-EMPTY:
 // CHECK-NEXT: #ifdef __cplusplus
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
diff --git a/test/Interop/SwiftToCxx/structs/struct-with-refcounted-member-execution.cpp b/test/Interop/SwiftToCxx/structs/struct-with-refcounted-member-execution.cpp
@@ -0,0 +1,48 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/struct-with-refcounted-member.swift -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/struct-with-refcounted-member.swift -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 %s
+
+// REQUIRES: executable_test
+
+#include <assert.h>
+#include "structs.h"
+
+int main() {
+  using namespace Structs;
+
+  // Ensure that the value destructor is called.
+  {
+    StructWithRefcountedMember value = returnNewStructWithRefcountedMember();
+  }
+  printBreak(1);
+// CHECK:      create RefCountedClass
+// CHECK-NEXT: destroy RefCountedClass
+// CHECK-NEXT: breakpoint 1
+
+  {
+    StructWithRefcountedMember value = returnNewStructWithRefcountedMember();
+    StructWithRefcountedMember copyValue(value);
+  }
+  printBreak(2);
+// CHECK-NEXT: create RefCountedClass
+// CHECK-NEXT: destroy RefCountedClass
+// CHECK-NEXT: breakpoint 2
+
+  {
+    StructWithRefcountedMember value = returnNewStructWithRefcountedMember();
+    StructWithRefcountedMember value2(returnNewStructWithRefcountedMember());
+  }
+  printBreak(3);
+// CHECK-NEXT: create RefCountedClass
+// CHECK-NEXT: create RefCountedClass
+// CHECK-NEXT: destroy RefCountedClass
+// CHECK-NEXT: destroy RefCountedClass
+// CHECK-NEXT: breakpoint 3
+  return 0;
+}
diff --git a/test/Interop/SwiftToCxx/structs/struct-with-refcounted-member.swift b/test/Interop/SwiftToCxx/structs/struct-with-refcounted-member.swift
@@ -0,0 +1,41 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -typecheck -module-name Structs -clang-header-expose-public-decls -emit-clang-header-path %t/structs.h
+// RUN: %FileCheck %s < %t/structs.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/structs.h -Wno-unused-function)
+
+class RefCountedClass {
+    init() {
+        print("create RefCountedClass")
+    }
+    deinit {
+        print("destroy RefCountedClass")
+    }
+}
+
+public struct StructWithRefcountedMember {
+    let x: RefCountedClass
+}
+
+public func returnNewStructWithRefcountedMember() -> StructWithRefcountedMember {
+    return StructWithRefcountedMember(x: RefCountedClass())
+}
+
+public func printBreak(_ x: Int) {
+    print("breakpoint \(x)")
+}
+
+// CHECK:      class StructWithRefcountedMember final {
+// CHECK-NEXT: public:
+// CHECK-NEXT:   inline ~StructWithRefcountedMember() {
+// CHECK-NEXT:     auto metadata = _impl::$s7Structs26StructWithRefcountedMemberVMa(0);
+// CHECK-NEXT:     auto *vwTable = *(reinterpret_cast<swift::_impl::ValueWitnessTable **>(metadata._0) - 1);
+// CHECK-NEXT:     vwTable->destroy(_getOpaquePointer(), metadata._0);
+// CHECK-NEXT:   }
+// CHECK-NEXT:   inline StructWithRefcountedMember(const StructWithRefcountedMember &other) {
+// CHECK-NEXT:     auto metadata = _impl::$s7Structs26StructWithRefcountedMemberVMa(0);
+// CHECK-NEXT:     auto *vwTable = *(reinterpret_cast<swift::_impl::ValueWitnessTable **>(metadata._0) - 1);
+// CHECK-NEXT:     vwTable->initializeWithCopy(_getOpaquePointer(), const_cast<char *>(other._getOpaquePointer()), metadata._0);
+// CHECK-NEXT:   }
+// CHECK-NEXT:   inline StructWithRefcountedMember(StructWithRefcountedMember &&) = default;
+// CHECK-NEXT: private:
diff --git a/test/Interop/SwiftToCxx/structs/swift-struct-in-cxx.swift b/test/Interop/SwiftToCxx/structs/swift-struct-in-cxx.swift
@@ -20,6 +20,12 @@
 // CHECK-NEXT: }
 
 // CHECK:      class StructWithIntField final {
+// CHECK-NEXT: public:
+// CHECK-NEXT:   inline ~StructWithIntField() {
+// CHECK:        }
+// CHECK-NEXT:   inline StructWithIntField(const StructWithIntField &other) {
+// CHECK:        }
+// CHECK-NEXT:   inline StructWithIntField(StructWithIntField &&) = default;
 // CHECK-NEXT: private:
 // CHECK-NEXT:   inline StructWithIntField() {}
 // CHECK-NEXT:   static inline StructWithIntField _make() { return StructWithIntField(); }
diff --git a/test/PrintAsCxx/empty.swift b/test/PrintAsCxx/empty.swift
@@ -35,6 +35,15 @@
 // CHECK-NEXT:  #include <stdbool.h>
 // CHECK-NEXT:  #include <string.h>
 // CHECK-NEXT:  #endif
+// CHECK-NEXT:  #if defined(__cplusplus)
+// CHECK-NEXT:  #if __has_include(<ptrauth.h>)
+// CHECK-NEXT:  # include <ptrauth.h>
+// CHECK-NEXT:  #else
+// CHECK-NEXT:  # ifndef __ptrauth_swift_value_witness_function_pointer
+// CHECK-NEXT:  #  define __ptrauth_swift_value_witness_function_pointer(x)
+// CHECK-NEXT:  # endif
+// CHECK-NEXT:  #endif
+// CHECK-NEXT:  #endif
 
 // CHECK-LABEL: !defined(SWIFT_TYPEDEFS)
 // CHECK-NEXT:  # define SWIFT_TYPEDEFS 1
