[interop][SwiftToCxx] correctly align allocation for opaque Swift value

Author: hyp

lib/PrintAsClang/PrintAsClang.cpp

@@ -103,6 +103,7 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
                "#include <cstddef>\n"
                "#include <cstdbool>\n"
                "#include <cstring>\n";
+        out << "#include <cstdlib>\n";
       },
       [&] {
         out << "#include <stdint.h>\n"

lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp

@@ -118,20 +118,40 @@ static void printTypeMetadataResponseType(SwiftToClangInteropContext &ctx,
                  funcSig.parameterTypes[0]);
 }
 
+static void printOpaqueAllocFee(raw_ostream &os) {
+  os << R"text(inline void * _Nonnull opaqueAlloc(size_t size, size_t align) {
+  if (align < sizeof(void *)) align = sizeof(void *);
+  void *r = nullptr;
+  int res = posix_memalign(&r, align, size);
+  (void)res;
+  return r;
+}
+inline void opaqueFree(void * _Nonnull p) {
+  free(p);
+}
+)text";
+}
+
 static void printSwiftResilientStorageClass(raw_ostream &os) {
-  // FIXME: alignment.
+  // FIXME: mark noexcept.
   auto name = cxx_synthesis::getCxxOpaqueStorageClassName();
+  static_assert(TargetValueWitnessFlags<uint64_t>::AlignmentMask ==
+                    TargetValueWitnessFlags<uint32_t>::AlignmentMask,
+                "alignment mask doesn't match");
   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";
+     << "(ValueWitnessTable * _Nonnull vwTable) : storage("
+        "reinterpret_cast<char *>(opaqueAlloc(vwTable->size, (vwTable->flags &"
+     << TargetValueWitnessFlags<uint64_t>::AlignmentMask << ") + 1))) { }\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 ~" << name
+     << "() { if (storage) { opaqueFree(static_cast<char "
+        "* _Nonnull>(storage)); } }\n";
   os << "  void operator =(" << name
      << "&& other) { auto temp = storage; storage = other.storage; "
         "other.storage = temp; }\n";
@@ -158,6 +178,8 @@ void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
             printValueWitnessTable(os);
           });
           os << "\n";
+          printOpaqueAllocFee(os);
+          os << "\n";
           printSwiftResilientStorageClass(os);
         });
   });

test/Inputs/clang-importer-sdk/usr/include/stdlib.h

@@ -0,0 +1,19 @@
+#if defined(_WIN32) || defined(WIN32)
+#define SDK_STDLIB_H
+#endif
+
+#ifndef SDK_STDLIB_H
+#define SDK_STDLIB_H
+
+#include <stdint.h>
+
+typedef long ldiv_t;
+typedef long long lldiv_t;
+
+int posix_memalign(void **, size_t, size_t);
+void free(void *);
+
+ldiv_t ldiv(long int, long int);
+lldiv_t lldiv(long long int, long long int);
+
+#endif // SDK_STDLIB_H

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

@@ -51,14 +51,25 @@
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
 // CHECK-EMPTY:
+// CHECK-NEXT: inline void * _Nonnull opaqueAlloc(size_t size, size_t align) {
+// CHECK-NEXT:   if (align < sizeof(void *)) align = sizeof(void *);
+// CHECK-NEXT:   void *r = nullptr;
+// CHECK-NEXT:   int res = posix_memalign(&r, align, size);
+// CHECK-NEXT:   (void)res;
+// CHECK-NEXT:   return r;
+// CHECK-NEXT: }
+// CHECK-NEXT: inline void opaqueFree(void * _Nonnull p) {
+// CHECK-NEXT:   free(p);
+// CHECK-NEXT: }
+// 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(ValueWitnessTable * _Nonnull vwTable) : storage(reinterpret_cast<char *>(opaqueAlloc(vwTable->size, (vwTable->flags &255) + 1))) { }
 // 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 ~OpaqueStorage() { if (storage) { opaqueFree(static_cast<char * _Nonnull>(storage)); } }
 // CHECK-NEXT:   void operator =(OpaqueStorage&& other) { auto temp = storage; storage = other.storage; other.storage = temp; }
 // CHECK-NEXT:   void operator =(const OpaqueStorage&) = delete;
 // CHECK-NEXT:   inline char * _Nonnull getOpaquePointer() { return static_cast<char * _Nonnull>(storage); }

test/PrintAsCxx/empty.swift

@@ -29,6 +29,7 @@
 // CHECK-NEXT:  #include <cstddef>
 // CHECK-NEXT:  #include <cstdbool>
 // CHECK-NEXT:  #include <cstring>
+// CHECK-NEXT:  #include <cstdlib>
 // CHECK-NEXT:  #else
 // CHECK-NEXT:  #include <stdint.h>
 // CHECK-NEXT:  #include <stddef.h>