[IRGen] Collect nc deinit metadata for outlining.

nate-chandler · nate-chandler · commit 22b48023a3ef · 2024-02-21T17:53:34.000-08:00
Some outlined functions call deinits for noncopyable values.  These
deinits require the metadata for the full type.

Teach the OutliningMetadataCollector to collect the metadata for these
types, when the new needsDeinit flag is set.

Also add the new needsLayout flag.  For now, all outlined functions need
it.
diff --git a/lib/IRGen/GenExistential.cpp b/lib/IRGen/GenExistential.cpp
@@ -253,7 +253,8 @@ namespace {
         asDerived().emitValueAssignWithCopy(IGF, destValue, srcValue);
         emitCopyOfTables(IGF, dest, src);
       } else {
-        OutliningMetadataCollector collector(IGF);
+        OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                             DeinitIsNotNeeded);
         collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                          IsNotInitialization, IsNotTake);
       }
@@ -267,7 +268,8 @@ namespace {
         asDerived().emitValueInitializeWithCopy(IGF, destValue, srcValue);
         emitCopyOfTables(IGF, dest, src);
       } else {
-        OutliningMetadataCollector collector(IGF);
+        OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                             DeinitIsNotNeeded);
         collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                          IsInitialization, IsNotTake);
       }
@@ -281,7 +283,8 @@ namespace {
         asDerived().emitValueAssignWithTake(IGF, destValue, srcValue);
         emitCopyOfTables(IGF, dest, src);
       } else {
-        OutliningMetadataCollector collector(IGF);
+        OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                             DeinitIsNotNeeded);
         collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                          IsNotInitialization, IsTake);
       }
@@ -295,7 +298,8 @@ namespace {
         asDerived().emitValueInitializeWithTake(IGF, destValue, srcValue);
         emitCopyOfTables(IGF, dest, src);
       } else {
-        OutliningMetadataCollector collector(IGF);
+        OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                             DeinitIsNotNeeded);
         collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                          IsInitialization, IsTake);
       }
@@ -307,7 +311,8 @@ namespace {
         Address valueAddr = projectValue(IGF, existential);
         asDerived().emitValueDestroy(IGF, valueAddr);
       } else {
-        OutliningMetadataCollector collector(IGF);
+        OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                             DeinitIsNotNeeded);
         collector.emitCallToOutlinedDestroy(existential, T, *this);
       }
     }
@@ -963,7 +968,8 @@ class OpaqueExistentialTypeInfo final :
                                                srcBuffer);
     } else {
       // Create an outlined function to avoid explosion
-      OutliningMetadataCollector collector(IGF);
+      OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                           DeinitIsNotNeeded);
       collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                        IsInitialization, IsNotTake);
     }
@@ -979,7 +985,8 @@ class OpaqueExistentialTypeInfo final :
       IGF.emitMemCpy(dest, src, getLayout().getSize(IGF.IGM));
     } else {
       // Create an outlined function to avoid explosion
-      OutliningMetadataCollector collector(IGF);
+      OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                           DeinitIsNotNeeded);
       collector.emitCallToOutlinedCopy(dest, src, T, *this,
                                        IsInitialization, IsTake);
     }
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -184,7 +184,8 @@ void LoadableTypeInfo::initializeWithCopy(IRGenFunction &IGF, Address destAddr,
     loadAsCopy(IGF, srcAddr, copy);
     initialize(IGF, copy, destAddr, true);
   } else {
-    OutliningMetadataCollector collector(IGF);
+    OutliningMetadataCollector collector(IGF, LayoutIsNeeded,
+                                         DeinitIsNotNeeded);
     // No need to collect anything because we assume loadable types can be
     // loaded without enums.
     collector.emitCallToOutlinedCopy(
diff --git a/lib/IRGen/Outlining.cpp b/lib/IRGen/Outlining.cpp
@@ -44,6 +44,18 @@ void OutliningMetadataCollector::collectTypeMetadataForLayout(SILType ty) {
   auto astType = ty.getASTType();
   auto &ti = IGF.IGM.getTypeInfoForLowered(astType);
 
+  if (needsDeinit) {
+    auto *nominal = ty.getASTType()->getAnyNominal();
+    if (nominal && nominal->getValueTypeDestructor()) {
+      assert(ty.isMoveOnly());
+      collectFormalTypeMetadata(ty.getASTType());
+    }
+  }
+
+  if (!needsLayout) {
+    return;
+  }
+
   // We don't need the metadata for fixed size types or types that are not ABI
   // accessible. Outlining will call the value witness of the enclosing type of
   // non ABI accessible field/element types.
@@ -139,11 +151,12 @@ irgen::getTypeAndGenericSignatureForManglingOutlineFunction(SILType type) {
 }
 
 bool TypeInfo::withMetadataCollector(
-    IRGenFunction &IGF, SILType T,
+    IRGenFunction &IGF, SILType T, LayoutIsNeeded_t needsLayout,
+    DeinitIsNeeded_t needsDeinit,
     llvm::function_ref<void(OutliningMetadataCollector &)> invocation) const {
   if (!T.hasLocalArchetype() &&
       !IGF.outliningCanCallValueWitnesses()) {
-    OutliningMetadataCollector collector(IGF);
+    OutliningMetadataCollector collector(IGF, needsLayout, needsDeinit);
     if (T.hasArchetype()) {
       collectMetadataForOutlining(collector, T);
     }
@@ -153,7 +166,7 @@ bool TypeInfo::withMetadataCollector(
 
   if (!T.hasArchetype()) {
     // The implementation will call vwt in this case.
-    OutliningMetadataCollector collector(IGF);
+    OutliningMetadataCollector collector(IGF, needsLayout, needsDeinit);
     invocation(collector);
     return true;
   }
@@ -164,9 +177,11 @@ bool TypeInfo::withMetadataCollector(
 void TypeInfo::callOutlinedCopy(IRGenFunction &IGF, Address dest, Address src,
                                 SILType T, IsInitialization_t isInit,
                                 IsTake_t isTake) const {
-  if (withMetadataCollector(IGF, T, [&](auto collector) {
-        collector.emitCallToOutlinedCopy(dest, src, T, *this, isInit, isTake);
-      })) {
+  if (withMetadataCollector(IGF, T, LayoutIsNeeded, DeinitIsNotNeeded,
+                            [&](auto collector) {
+                              collector.emitCallToOutlinedCopy(
+                                  dest, src, T, *this, isInit, isTake);
+                            })) {
     return;
   }
 
@@ -186,6 +201,8 @@ void OutliningMetadataCollector::emitCallToOutlinedCopy(
                             Address dest, Address src,
                             SILType T, const TypeInfo &ti, 
                             IsInitialization_t isInit, IsTake_t isTake) const {
+  assert(needsLayout);
+  assert(!needsDeinit);
   llvm::SmallVector<llvm::Value *, 4> args;
   args.push_back(IGF.Builder.CreateElementBitCast(src, ti.getStorageType())
                             .getAddress());
@@ -359,9 +376,10 @@ void TypeInfo::callOutlinedDestroy(IRGenFunction &IGF,
   if (IGF.IGM.getTypeLowering(T).isTrivial())
     return;
 
-  if (withMetadataCollector(IGF, T, [&](auto collector) {
-        collector.emitCallToOutlinedDestroy(addr, T, *this);
-      })) {
+  if (withMetadataCollector(
+          IGF, T, LayoutIsNeeded, DeinitIsNeeded, [&](auto collector) {
+            collector.emitCallToOutlinedDestroy(addr, T, *this);
+          })) {
     return;
   }
 
@@ -370,6 +388,8 @@ void TypeInfo::callOutlinedDestroy(IRGenFunction &IGF,
 
 void OutliningMetadataCollector::emitCallToOutlinedDestroy(
                       Address addr, SILType T, const TypeInfo &ti) const {
+  assert(needsLayout);
+  assert(needsDeinit);
   llvm::SmallVector<llvm::Value *, 4> args;
   args.push_back(IGF.Builder.CreateElementBitCast(addr, ti.getStorageType())
                             .getAddress());
diff --git a/lib/IRGen/Outlining.h b/lib/IRGen/Outlining.h
@@ -20,7 +20,6 @@
 #include "LocalTypeDataKind.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/MapVector.h"
-#include "LocalTypeDataKind.h"
 
 namespace llvm {
   class Value;
@@ -41,6 +40,16 @@ class IRGenFunction;
 class IRGenModule;
 class TypeInfo;
 
+enum LayoutIsNeeded_t : bool {
+  LayoutIsNotNeeded = false,
+  LayoutIsNeeded = true
+};
+
+enum DeinitIsNeeded_t : bool {
+  DeinitIsNotNeeded = false,
+  DeinitIsNeeded = true
+};
+
 /// A helper class for emitting outlined value operations.
 ///
 /// The use-pattern for this class is:
@@ -51,12 +60,17 @@ class TypeInfo;
 class OutliningMetadataCollector {
 public:
   IRGenFunction &IGF;
+  const unsigned needsLayout : 1;
+  const unsigned needsDeinit : 1;
+
 private:
   llvm::MapVector<LocalTypeDataKey, llvm::Value *> Values;
   friend class IRGenModule;
 
 public:
-  OutliningMetadataCollector(IRGenFunction &IGF) : IGF(IGF) {}
+  OutliningMetadataCollector(IRGenFunction &IGF, LayoutIsNeeded_t needsLayout,
+                             DeinitIsNeeded_t needsDeinitTypes)
+      : IGF(IGF), needsLayout(needsLayout), needsDeinit(needsDeinitTypes) {}
 
   void collectTypeMetadataForLayout(SILType type);
 
diff --git a/lib/IRGen/TypeInfo.h b/lib/IRGen/TypeInfo.h
@@ -26,6 +26,7 @@
 #define SWIFT_IRGEN_TYPEINFO_H
 
 #include "IRGen.h"
+#include "Outlining.h"
 #include "swift/AST/ReferenceCounting.h"
 #include "llvm/ADT/MapVector.h"
 
@@ -575,7 +576,8 @@ class TypeInfo {
   /// Returns whether there was an appropriate metadata collector (and whether
   /// \p invocation was called.
   bool withMetadataCollector(
-      IRGenFunction &IGF, SILType T,
+      IRGenFunction &IGF, SILType T, LayoutIsNeeded_t needsLayout,
+      DeinitIsNeeded_t needsDeinit,
       llvm::function_ref<void(OutliningMetadataCollector &)> invocation) const;
 
   void callOutlinedCopy(IRGenFunction &IGF, Address dest, Address src,
diff --git a/test/IRGen/moveonly_value_functions.swift b/test/IRGen/moveonly_value_functions.swift
@@ -0,0 +1,130 @@
+// RUN: %target-swift-emit-irgen -O                          \
+// RUN:     -enable-experimental-feature NoncopyableGenerics \
+// RUN:     -disable-type-layout                             \
+// RUN:     %s                                               \
+// RUN: |                                                    \
+// RUN: %FileCheck %s
+
+@_silgen_name("external_symbol")
+func external_symbol()
+
+public class C<T> {
+  deinit {
+    external_symbol()
+  }
+}
+
+public struct InnerDeinitingReleasableNC<T> : ~Copyable {
+  public let i1: Int
+  public let i2: Int
+  public let i3: Int
+  public let i4: Int
+  public let c1: C<T>
+  public let c2: C<T>
+  public let c3: C<T>
+  public let c4: C<T>
+
+  deinit {
+    external_symbol()
+  }
+}
+
+public struct InnerDeinitingDestructableNC<T> : ~Copyable {
+  public let t: T
+  public let i1: Int
+  public let i2: Int
+  public let i3: Int
+  public let i4: Int
+  public let c1: C<T>
+  public let c2: C<T>
+  public let c3: C<T>
+  public let c4: C<T>
+
+  deinit {
+    external_symbol()
+  }
+}
+
+public struct OuterDeinitingNC_1<T> : ~Copyable {
+  public let i1: Int
+  public let c1: C<T>
+  public let i: InnerDeinitingReleasableNC<T>
+  deinit {
+    external_symbol()
+  }
+}
+
+public struct OuterNC_1<T> : ~Copyable {
+  public let i1: Int
+  public let c1: C<T>
+  public let i: InnerDeinitingReleasableNC<T>
+}
+
+public struct OuterNC_2<T> : ~Copyable {
+  public let i1: Int
+  public let c1: C<T>
+  public let i: InnerDeinitingDestructableNC<T>
+}
+
+// Destroyed value:
+// - has deinit
+// On lifetime end:
+// - call deinit
+// CHECK-LABEL: define{{.*}} @"$s24moveonly_value_functions22takeOuterDeinitingNC_1yyAA0efG2_1VyxGnlF"(
+// CHECK-SAME:      ptr{{.*}} %0,
+// CHECK-SAME:      ptr %T)
+// CHECK-SAME:  {
+// CHECK:         [[RESPONSE:%[^,]+]] = call{{.*}} @"$s24moveonly_value_functions18OuterDeinitingNC_1VMa"(
+//           :        i64 0,
+// CHECK-SAME:        ptr %T)
+// CHECK:         [[OUTER_DEINITING_NC_1_METADATA:%[^,]+]] = extractvalue %swift.metadata_response [[RESPONSE]]
+// CHECK:         call{{.*}} @"$s24moveonly_value_functions18OuterDeinitingNC_1VfD"(
+// CHECK-SAME:        ptr [[OUTER_DEINITING_NC_1_METADATA]],
+// CHECK-SAME:        ptr{{.*}} %0)
+// CHECK:       }
+public func takeOuterDeinitingNC_1<T>(_ t: consuming OuterDeinitingNC_1<T>) {
+  external_symbol()
+}
+
+// If the destroyed value has no deinit, is releasable, and contains a
+// noncopyable value with a deinit, call the outlined destroy function.
+// Destroyed value:
+// - has NO deinit
+// - contains value type with deinit
+// - is NOT releasable
+// On lifetime end:
+// - call outlined destroy destroy
+// CHECK-LABEL: define{{.*}} @"$s24moveonly_value_functions13takeOuterNC_2yyAA0eF2_2VyxGnlF"(
+// CHECK-SAME:      ptr{{.*}} %0,
+// CHECK-SAME:      ptr %T)
+// CHECK-SAME:  {
+// CHECK:         [[RESPONSE:%[^,]+]] = call{{.*}} @"$s24moveonly_value_functions28InnerDeinitingDestructableNCVMa"(
+// CHECK-SAME:        i64 0,
+// CHECK-SAME:        ptr %T)
+// CHECK:         [[INNER_DEINITING_DESTRUCTABLE_NC_METADATA:%[^,]+]] = extractvalue %swift.metadata_response [[RESPONSE]]
+// CHECK:         call{{.*}} @"$s24moveonly_value_functions9OuterNC_2VyxGlWOh"(
+// CHECK-SAME:        ptr %0,
+// CHECK-SAME:        ptr %T,
+// CHECK-SAME:        ptr [[INNER_DEINITING_DESTRUCTABLE_NC_METADATA]],
+//           :        ptr %4)
+// CHECK:       }
+
+// Verify that the outlined destroy function takes the metadata for the
+// move-only-with-deinit type InnerDeinitingDestructable<T> and passes it along
+// to that deinit.
+// $s24moveonly_value_functions9OuterNC_2VyxGlWOh ---> outlined destroy of moveonly_value_functions.OuterNC_2<A>
+// CHECK-LABEL: define{{.*}} @"$s24moveonly_value_functions9OuterNC_2VyxGlWOh"(
+// CHECK-SAME:      ptr %0, 
+// CHECK-SAME:      ptr %T, 
+// CHECK-SAME:      ptr %"InnerDeinitingDestructableNC<T>", 
+// CHECK-SAME:      ptr %"OuterNC_2<T>")
+// CHECK-SAME:  {
+//                ...
+//                ...
+// CHECK:         call{{.*}} @"$s24moveonly_value_functions28InnerDeinitingDestructableNCVfD"(
+// CHECK-SAME:        ptr %"InnerDeinitingDestructableNC<T>", 
+//           :        ptr noalias swiftself %3)
+// CHECK:       }
+public func takeOuterNC_2<T>(_ o: consuming OuterNC_2<T>) {
+  external_symbol()
+}
