[IRGen+Runtime] Add support for initializeBufferWithCopyOfBuffer to layout strings (#66965)

Author: drexin

include/swift/Runtime/RuntimeFunctions.def

@@ -2315,6 +2315,17 @@ FUNCTION(GenericInitWithTake,
          ATTRS(NoUnwind),
          EFFECT(Refcounting))
 
+// void *swift_generic_initializeBufferWithCopyOfBuffer(ValueBuffer* dest, ValueBuffer* src, const Metadata* type);
+FUNCTION(GenericInitializeBufferWithCopyOfBuffer,
+         swift_generic_initializeBufferWithCopyOfBuffer,
+         C_CC, AlwaysAvailable,
+         RETURNS(Int8PtrTy),
+         ARGS(getFixedBufferTy()->getPointerTo(),
+              getFixedBufferTy()->getPointerTo(),
+              TypeMetadataPtrTy),
+         ATTRS(NoUnwind),
+         EFFECT(Refcounting))
+
 // unsigned swift_enumSimple_getEnumTag(swift::OpaqueValue *address,
 //                                      const Metadata *metadata);
 FUNCTION(EnumSimpleGetEnumTag,

lib/IRGen/GenValueWitness.cpp

@@ -1012,6 +1012,26 @@ addValueWitness(IRGenModule &IGM, ConstantStructBuilder &B, ValueWitness index,
         return addFunction(getInitWithCopyStrongFunction(IGM));
       }
     }
+
+    if (IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) &&
+        IGM.getOptions().EnableLayoutStringValueWitnesses) {
+      auto ty = boundGenericCharacteristics
+                    ? boundGenericCharacteristics->concreteType
+                    : concreteType;
+      auto &typeInfo = boundGenericCharacteristics
+                           ? *boundGenericCharacteristics->TI
+                           : concreteTI;
+      if (auto *typeLayoutEntry = typeInfo.buildTypeLayoutEntry(
+              IGM, ty, /*useStructLayouts*/ true)) {
+        auto genericSig = concreteType.getNominalOrBoundGenericNominal()
+                              ->getGenericSignature();
+        if (typeLayoutEntry->layoutString(IGM, genericSig) ||
+            isRuntimeInstatiatedLayoutString(IGM, typeLayoutEntry)) {
+          return addFunction(
+              IGM.getGenericInitializeBufferWithCopyOfBufferFn());
+        }
+      }
+    }
     goto standard;
 
   case ValueWitness::InitializeWithTake:

stdlib/public/runtime/BytecodeLayouts.cpp

@@ -784,6 +784,20 @@ swift_singlePayloadEnumGeneric_getEnumTag(swift::OpaqueValue *address,
   return 0;
 }
 
+extern "C" swift::OpaqueValue *
+swift_generic_initializeBufferWithCopyOfBuffer(swift::ValueBuffer *dest,
+                                               swift::ValueBuffer *src,
+                                               const Metadata *metadata) {
+  if (metadata->getValueWitnesses()->isValueInline()) {
+    return swift_generic_initWithCopy((swift::OpaqueValue *)dest,
+                                      (swift::OpaqueValue *)src, metadata);
+  } else {
+    memcpy(dest, src, sizeof(swift::HeapObject *));
+    swift_retain(*(swift::HeapObject **)src);
+    return (swift::OpaqueValue *)&(*(swift::HeapObject **)dest)[1];
+  }
+}
+
 void swift::swift_resolve_resilientAccessors(uint8_t *layoutStr,
                                              size_t layoutStrOffset,
                                              const uint8_t *fieldLayoutStr,

stdlib/public/runtime/BytecodeLayouts.h

@@ -113,6 +113,11 @@ swift::OpaqueValue *swift_generic_initWithTake(swift::OpaqueValue *dest,
                                                swift::OpaqueValue *src,
                                                const Metadata *metadata);
 SWIFT_RUNTIME_EXPORT
+swift::OpaqueValue *
+swift_generic_initializeBufferWithCopyOfBuffer(swift::ValueBuffer *dest,
+                                               swift::ValueBuffer *src,
+                                               const Metadata *metadata);
+SWIFT_RUNTIME_EXPORT
 unsigned swift_enumSimple_getEnumTag(swift::OpaqueValue *address,
                                      const Metadata *metadata);
 SWIFT_RUNTIME_EXPORT

test/Interpreter/Inputs/layout_string_witnesses_types.swift

@@ -125,6 +125,11 @@ public struct ExistentialWrapper {
     }
 }
 
+@inline(never)
+public func createExistentialWrapper(_ x: any SomeProtocol) -> ExistentialWrapper {
+    return ExistentialWrapper(x: x)
+}
+
 public protocol SomeClassProtocol: AnyObject {}
 
 public struct ExistentialRefWrapper {

test/Interpreter/layout_string_witnesses_static.swift

@@ -193,7 +193,7 @@ class ClassWithSomeProtocol: SomeProtocol {
     }
 }
 
-func testExistential() {
+func testExistentialClass() {
     let ptr = UnsafeMutablePointer<ExistentialWrapper>.allocate(capacity: 1)
 
     do {
@@ -220,7 +220,78 @@ func testExistential() {
     ptr.deallocate()
 }
 
-testExistential()
+testExistentialClass()
+
+struct StructWithSomeProtocolInline: SomeProtocol {
+    let y: Int = 0
+    let x: SimpleClass
+}
+
+func testExistentialStructInline() {
+    let ptr = UnsafeMutablePointer<ExistentialWrapper>.allocate(capacity: 1)
+
+    do {
+        let x = StructWithSomeProtocolInline(x: SimpleClass(x: 23))
+        testInit(ptr, to: createExistentialWrapper(x))
+    }
+
+    do {
+        let y = StructWithSomeProtocolInline(x: SimpleClass(x: 32))
+
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: createExistentialWrapper(y))
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testExistentialStructInline()
+
+struct StructWithSomeProtocolBox: SomeProtocol {
+    let y: Int = 0
+    let x: SimpleClass
+    let z: Int = 0
+    let zz: Int = 0
+    let zzz: Int = 0
+}
+
+func testExistentialStructBox() {
+    let ptr = UnsafeMutablePointer<ExistentialWrapper>.allocate(capacity: 1)
+
+    do {
+        let x = StructWithSomeProtocolBox(x: SimpleClass(x: 23))
+        testInit(ptr, to: createExistentialWrapper(x))
+    }
+
+    do {
+        let y = StructWithSomeProtocolBox(x: SimpleClass(x: 32))
+
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: createExistentialWrapper(y))
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testExistentialStructBox()
 
 class ClassWithSomeClassProtocol: SomeClassProtocol {
     deinit {