[PackMetadataMarkerInserter] Insert fewer markers.

Rather than emitting markers for every single instruction of the
relevant sorts, check whether the instructions' types involve packs.
Only record them as potential on-stack pack metadata emitters if they
do.

Author: nate-chandler

lib/SIL/IR/SILInstruction.cpp

@@ -1295,17 +1295,41 @@ bool SILInstruction::isDeallocatingStack() const {
 bool SILInstruction::mayRequirePackMetadata() const {
   switch (getKind()) {
   case SILInstructionKind::AllocPackInst:
-  case SILInstructionKind::PartialApplyInst:
-  case SILInstructionKind::ApplyInst:
-  case SILInstructionKind::BeginApplyInst:
-  case SILInstructionKind::TryApplyInst:
-  case SILInstructionKind::DebugValueInst:
-  case SILInstructionKind::MetatypeInst:
   case SILInstructionKind::TuplePackElementAddrInst:
   case SILInstructionKind::OpenPackElementInst:
-  case SILInstructionKind::ClassMethodInst:
-  case SILInstructionKind::WitnessMethodInst:
     return true;
+  case SILInstructionKind::PartialApplyInst:
+  case SILInstructionKind::ApplyInst:
+  case SILInstructionKind::BeginApplyInst:
+  case SILInstructionKind::TryApplyInst: {
+    // Check the function type for packs.
+    auto apply = ApplySite::isa(const_cast<SILInstruction *>(this));
+    if (apply.getCallee()->getType().hasPack())
+      return true;
+    // Check the substituted types for packs.
+    for (auto ty : apply.getSubstitutionMap().getReplacementTypes()) {
+      if (ty->hasPack())
+        return true;
+    }
+    return false;
+  }
+  case SILInstructionKind::DebugValueInst: {
+    auto *dvi = cast<DebugValueInst>(this);
+    return dvi->getOperand()->getType().hasPack();
+  }
+  case SILInstructionKind::MetatypeInst: {
+    auto *mi = cast<MetatypeInst>(this);
+    return mi->getType().hasPack();
+  }
+  case SILInstructionKind::ClassMethodInst: {
+    auto *cmi = cast<ClassMethodInst>(this);
+    return cmi->getOperand()->getType().hasPack();
+  }
+  case SILInstructionKind::WitnessMethodInst: {
+    auto *wmi = cast<WitnessMethodInst>(this);
+    auto ty = wmi->getLookupType();
+    return ty->hasPack();
+  }
   default:
     return false;
   }

test/IRGen/pack_metadata_marker_inserter.sil

@@ -26,6 +26,10 @@ struct GV<each T> {
   var tu: (repeat each T)
 }
 
+struct G<T> {
+  var t: T
+}
+
 sil @takeTypePack : $<each T>() -> ()
 sil @take : $<T>(@in T) -> ()
 
@@ -56,6 +60,16 @@ entry:
 // BEGIN: Instructions: Apply                                                 {{
 // =============================================================================
 
+// CHECK-SIL-LABEL: sil @no_markers_for_apply_without_pack : $@convention(thin) () -> () {
+// CHECK-SIL-NOT:     alloc_pack_metadata
+// CHECK-SIL-LABEL: } // end sil function 'no_markers_for_apply_without_pack'
+sil @no_markers_for_apply_without_pack : $() -> () {
+entry:
+  apply undef() : $@convention(thin) () -> ()
+  %retval = tuple ()
+  return %retval : $()
+}
+
 // A pack directly in the signature results in markers.
 // CHECK-SIL-LABEL: sil @forward_type_pack {{.*}} {
 // CHECK-SIL:         [[TAKE:%[^,]+]] = function_ref @takeTypePack
@@ -106,6 +120,33 @@ entry(%gv : $*GV<T, S2, S3>):
   %retval = tuple ()
   return %retval : $()
 }
+
+// A _non_-variadic generic type within the signature doesn't entail a marker.
+// CHECK-SIL-LABEL: sil @apply_with_generic_instance : {{.*}} {
+// CHECK-SIL-NOT:     alloc_pack_metadata
+// CHECK-SIL-LABEL: } // end sil function 'apply_with_generic_instance'
+sil @apply_with_generic_instance : $<T>(@in G<T>) -> () {
+entry(%g : $*G<T>):
+  %take = function_ref @take : $@convention(thin) <T>(@in T) -> ()
+  apply %take<G<T>>(%g) : $@convention(thin) <T>(@in T) -> ()
+  %retval = tuple ()
+  return %retval : $()
+}
+
+// CHECK-SIL-LABEL: sil @apply_variadic_with_generic_instance : {{.*}} {
+// CHECK-SIL:         [[TAKE:%[^,]+]] = function_ref @takeTypePack
+// CHECK-SIL:         [[MARKER:%[^,]+]] = alloc_pack_metadata
+// CHECK-SIL:         apply [[TAKE]]
+// CHECK-SIL:         dealloc_pack_metadata [[MARKER]]
+// CHECK-SIL-LABEL: } // end sil function 'apply_variadic_with_generic_instance'
+sil @apply_variadic_with_generic_instance : $<T>() -> () {
+entry:
+  %take = function_ref @takeTypePack : $@convention(thin) <each T>() -> ()
+  apply %take<Pack{G<T>}>() : $@convention(thin) <each T>() -> ()
+  %retval = tuple ()
+  return %retval : $()
+}
+
 // =============================================================================
 // FINISH: Instructions: Apply                                                }}
 // =============================================================================