[IRGen] Pass deinit metadata to outlined release.

Given a releasable value which contains a noncopyable value type with a
deinit, that values outlined release function, among other things, must
call the deinit of that noncopyable value type.  In order to do that,
its type metadata must be passed to the value function if it has an
archetype.

Author: nate-chandler

lib/IRGen/IRGenModule.h

@@ -1193,8 +1193,10 @@ class IRGenModule {
   llvm::Constant *getOrCreateRetainFunction(const TypeInfo &objectTI, SILType t,
                               llvm::Type *llvmType, Atomicity atomicity);
 
-  llvm::Constant *getOrCreateReleaseFunction(const TypeInfo &objectTI, SILType t,
-                              llvm::Type *llvmType, Atomicity atomicity);
+  llvm::Constant *
+  getOrCreateReleaseFunction(const TypeInfo &objectTI, SILType t,
+                             llvm::Type *llvmType, Atomicity atomicity,
+                             const OutliningMetadataCollector &collector);
 
   llvm::Constant *getOrCreateOutlinedInitializeWithTakeFunction(
                               SILType objectType, const TypeInfo &objectTI,

lib/IRGen/Outlining.cpp

@@ -464,33 +464,44 @@ llvm::Constant *IRGenModule::getOrCreateRetainFunction(const TypeInfo &ti,
 
 void TypeInfo::callOutlinedRelease(IRGenFunction &IGF, Address addr, SILType T,
                                    Atomicity atomicity) const {
-  llvm::Type *llvmType = addr.getAddress()->getType();
-  auto *outlinedF = cast<llvm::Function>(
-      IGF.IGM.getOrCreateReleaseFunction(*this, T, llvmType, atomicity));
-  llvm::Value *args[] = {addr.getAddress()};
+  OutliningMetadataCollector collector(IGF, LayoutIsNotNeeded, DeinitIsNeeded);
+  collectMetadataForOutlining(collector, T);
+  collector.emitCallToOutlinedRelease(addr, T, *this, atomicity);
+}
+
+void OutliningMetadataCollector::emitCallToOutlinedRelease(
+    Address addr, SILType T, const TypeInfo &ti, Atomicity atomicity) const {
+  assert(!needsLayout);
+  assert(needsDeinit);
+  llvm::SmallVector<llvm::Value *, 4> args;
+  args.push_back(addr.getAddress());
+  addMetadataArguments(args);
+  auto *outlinedF = cast<llvm::Function>(IGF.IGM.getOrCreateReleaseFunction(
+      ti, T, addr.getAddress()->getType(), atomicity, *this));
   llvm::CallInst *call =
       IGF.Builder.CreateCall(outlinedF->getFunctionType(), outlinedF, args);
   call->setCallingConv(IGF.IGM.DefaultCC);
 }
 
-llvm::Constant *
-IRGenModule::getOrCreateReleaseFunction(const TypeInfo &ti,
-                                        SILType t,
-                                        llvm::Type *llvmType,
-                                        Atomicity atomicity) {
+llvm::Constant *IRGenModule::getOrCreateReleaseFunction(
+    const TypeInfo &ti, SILType t, llvm::Type *ptrTy, Atomicity atomicity,
+    const OutliningMetadataCollector &collector) {
   auto *loadableTI = cast<LoadableTypeInfo>(&ti);
   IRGenMangler mangler;
   auto manglingBits =
     getTypeAndGenericSignatureForManglingOutlineFunction(t);
   auto funcName = mangler.mangleOutlinedReleaseFunction(manglingBits.first,
                                                         manglingBits.second);
-  llvm::Type *argTys[] = {llvmType};
+  llvm::SmallVector<llvm::Type *, 4> argTys;
+  argTys.push_back(ptrTy);
+  collector.addMetadataParameterTypes(argTys);
   return getOrCreateHelperFunction(
-      funcName, llvmType, argTys,
+      funcName, ptrTy, argTys,
       [&](IRGenFunction &IGF) {
-        auto it = IGF.CurFn->arg_begin();
-        Address addr(&*it++, loadableTI->getStorageType(),
+        Explosion params = IGF.collectParameters();
+        Address addr(params.claimNext(), loadableTI->getStorageType(),
                      loadableTI->getFixedAlignment());
+        collector.bindMetadataParameters(IGF, params);
         Explosion loaded;
         loadableTI->loadAsTake(IGF, addr, loaded);
         loadableTI->consume(IGF, loaded, atomicity, t);

lib/IRGen/Outlining.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_IRGEN_OUTLINING_H
 #define SWIFT_IRGEN_OUTLINING_H
 
+#include "IRGen.h"
 #include "LocalTypeDataKind.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/MapVector.h"
@@ -79,6 +80,8 @@ class OutliningMetadataCollector {
                               IsInitialization_t isInit, IsTake_t isTake) const;
   void emitCallToOutlinedDestroy(Address addr, SILType T,
                                  const TypeInfo &ti) const;
+  void emitCallToOutlinedRelease(Address addr, SILType T, const TypeInfo &ti,
+                                 Atomicity atomicity) const;
 
 private:
   void collectFormalTypeMetadata(CanType type);

test/IRGen/moveonly_value_functions.swift

@@ -86,6 +86,45 @@ 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 release function.
+// Destroyed value:
+// - has NO deinit
+// - contains value type with deinit
+// - is releasable
+// On lifetime end:
+// - call outlined release function
+// CHECK-LABEL: define{{.*}} @"$s24moveonly_value_functions13takeOuterNC_1yyAA0eF2_1VyxGnlF"(
+// CHECK-SAME:      ptr{{.*}} %0,
+// CHECK-SAME:      ptr %T)
+// CHECK-SAME:  {
+// CHECK:         [[RESPONSE:%[^,]+]] = call{{.*}} @"$s24moveonly_value_functions26InnerDeinitingReleasableNCVMa"(
+//           :        i64 0,
+// CHECK-SAME:        ptr %T)
+// CHECK:         [[INNER_DEINITING_RELEASABLE_NC_METADATA:%[^,]+]] = extractvalue %swift.metadata_response [[RESPONSE]]
+// CHECK:         call{{.*}} @"$s24moveonly_value_functions9OuterNC_1VyxGlWOs"(
+// CHECK-SAME:        ptr %0,
+// CHECK-SAME:        ptr [[INNER_DEINITING_RELEASABLE_NC_METADATA]])
+// CHECK:       }
+
+// Verify that the outlined release function takes the metadata for the
+// move-only-with-deinit type InnerDeinitingReleasableNC<T> and passes it along
+// to that deinit.
+// $s24moveonly_value_functions9OuterNC_1VyxGlWOs ---> outlined release of moveonly_value_functions.OuterNC_2<A>
+// CHECK-LABEL: define{{.*}} @"$s24moveonly_value_functions9OuterNC_1VyxGlWOs"(
+// CHECK-SAME:      ptr %0,
+// CHECK-SAME:      ptr %"InnerDeinitingReleasableNC<T>")
+// CHECK-SAME:  {
+//                ...
+//                ...
+// CHECK:         call swiftcc void @"$s24moveonly_value_functions26InnerDeinitingReleasableNCVfD"(
+// CHECK-SAME:        ptr %"InnerDeinitingReleasableNC<T>",
+//           :        ptr noalias nocapture swiftself dereferenceable(64) %deinit.arg)
+// CHECK:       }
+public func takeOuterNC_1<T>(_ o: consuming OuterNC_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: