[GenPack] NFC: Stack de/alloc traffics in shapes.

When allocating, the shape is computed, and it (its constant value if
any) is needed when deallocating, so return the shape along with the
address.  And when deallocating, accept the shape, which the client
received during allocation, rather than requiring that the caller
compute the fixed size.

Author: nate-chandler

lib/IRGen/GenPack.cpp

@@ -445,15 +445,16 @@ static void emitPackExpansionMetadataPack(IRGenFunction &IGF, Address pack,
       });
 }
 
-StackAddress
-irgen::emitTypeMetadataPack(IRGenFunction &IGF,
-                            CanPackType packType,
+std::pair<StackAddress, llvm::Value *>
+irgen::emitTypeMetadataPack(IRGenFunction &IGF, CanPackType packType,
                             DynamicMetadataRequest request) {
   auto *shape = IGF.emitPackShapeExpression(packType);
 
   if (auto *constantInt = dyn_cast<llvm::ConstantInt>(shape)) {
     assert(packType->getNumElements() == constantInt->getValue());
-    return StackAddress(emitFixedSizeMetadataPackRef(IGF, packType, request));
+    auto pack =
+        StackAddress(emitFixedSizeMetadataPackRef(IGF, packType, request));
+    return {pack, constantInt};
   }
 
   assert(packType->containsPackExpansionType());
@@ -488,7 +489,13 @@ irgen::emitTypeMetadataPack(IRGenFunction &IGF,
 
   visitPackExplosion(IGF, packType, visitFn);
 
-  return pack;
+  return {pack, shape};
+}
+
+static Optional<unsigned> countForShape(llvm::Value *shape) {
+  if (auto *constant = dyn_cast<llvm::ConstantInt>(shape))
+    return constant->getValue().getZExtValue();
+  return llvm::None;
 }
 
 MetadataResponse
@@ -497,7 +504,10 @@ irgen::emitTypeMetadataPackRef(IRGenFunction &IGF, CanPackType packType,
   if (auto result = tryGetLocalPackTypeMetadata(IGF, packType, request))
     return result;
 
-  auto pack = emitTypeMetadataPack(IGF, packType, request);
+  StackAddress pack;
+  llvm::Value *shape;
+  std::tie(pack, shape) = emitTypeMetadataPack(IGF, packType, request);
+
   auto *metadata = pack.getAddress().getAddress();
   metadata = IGF.Builder.CreatePointerCast(
       metadata, IGF.IGM.TypeMetadataPtrTy->getPointerTo());
@@ -573,15 +583,16 @@ static void emitPackExpansionWitnessTablePack(
       });
 }
 
-StackAddress irgen::emitWitnessTablePack(IRGenFunction &IGF,
-                                         CanPackType packType,
-                                         PackConformance *packConformance) {
+std::pair<StackAddress, llvm::Value *>
+irgen::emitWitnessTablePack(IRGenFunction &IGF, CanPackType packType,
+                            PackConformance *packConformance) {
   auto *shape = IGF.emitPackShapeExpression(packType);
 
   if (auto *constantInt = dyn_cast<llvm::ConstantInt>(shape)) {
     assert(packType->getNumElements() == constantInt->getValue());
-    return StackAddress(
+    auto pack = StackAddress(
         emitFixedSizeWitnessTablePack(IGF, packType, packConformance));
+    return {pack, constantInt};
   }
 
   assert(packType->containsPackExpansionType());
@@ -618,16 +629,16 @@ StackAddress irgen::emitWitnessTablePack(IRGenFunction &IGF,
 
   visitPackExplosion(IGF, packType, visitFn);
 
-  return pack;
+  return {pack, shape};
 }
 
 void irgen::cleanupWitnessTablePack(IRGenFunction &IGF, StackAddress pack,
-                                    Optional<unsigned> elementCount) {
+                                    llvm::Value *shape) {
   if (pack.getExtraInfo()) {
     IGF.emitDeallocateDynamicAlloca(pack);
-  } else {
+  } else if (auto count = countForShape(shape)) {
     IGF.Builder.CreateLifetimeEnd(pack.getAddress(),
-                                  IGF.IGM.getPointerSize() * (*elementCount));
+                                  IGF.IGM.getPointerSize() * (count.value()));
   }
 }
 
@@ -650,7 +661,9 @@ llvm::Value *irgen::emitWitnessTablePackRef(IRGenFunction &IGF,
   if (auto *wtable = tryGetLocalPackTypeData(IGF, packType, localDataKind))
     return wtable;
 
-  auto pack = emitWitnessTablePack(IGF, packType, conformance);
+  StackAddress pack;
+  llvm::Value *shape;
+  std::tie(pack, shape) = emitWitnessTablePack(IGF, packType, conformance);
 
   auto *result = pack.getAddress().getAddress();
   result = IGF.Builder.CreatePointerCast(
@@ -1018,14 +1031,13 @@ void irgen::bindOpenedElementArchetypesAtIndex(IRGenFunction &IGF,
   }
 }
 
-void irgen::cleanupTypeMetadataPack(IRGenFunction &IGF,
-                                    StackAddress pack,
-                                    Optional<unsigned> elementCount) {
+void irgen::cleanupTypeMetadataPack(IRGenFunction &IGF, StackAddress pack,
+                                    llvm::Value *shape) {
   if (pack.getExtraInfo()) {
     IGF.emitDeallocateDynamicAlloca(pack);
-  } else {
+  } else if (auto count = countForShape(shape)) {
     IGF.Builder.CreateLifetimeEnd(pack.getAddress(),
-                                  IGF.IGM.getPointerSize() * (*elementCount));
+                                  IGF.IGM.getPointerSize() * (*count));
   }
 }
 

lib/IRGen/GenPack.h

@@ -43,9 +43,8 @@ emitPackArchetypeMetadataRef(IRGenFunction &IGF,
                              CanPackArchetypeType type,
                              DynamicMetadataRequest request);
 
-StackAddress
-emitTypeMetadataPack(IRGenFunction &IGF,
-                     CanPackType packType,
+std::pair<StackAddress, llvm::Value *>
+emitTypeMetadataPack(IRGenFunction &IGF, CanPackType packType,
                      DynamicMetadataRequest request);
 
 MetadataResponse
@@ -68,18 +67,18 @@ emitTypeMetadataPackElementRef(IRGenFunction &IGF, CanPackType packType,
                                DynamicMetadataRequest request,
                                llvm::SmallVectorImpl<llvm::Value *> &wtables);
 
-void cleanupTypeMetadataPack(IRGenFunction &IGF,
-                             StackAddress pack,
-                             Optional<unsigned> elementCount);
+void cleanupTypeMetadataPack(IRGenFunction &IGF, StackAddress pack,
+                             llvm::Value *shape);
 
-StackAddress emitWitnessTablePack(IRGenFunction &IGF, CanPackType packType,
-                                  PackConformance *conformance);
+std::pair<StackAddress, llvm::Value *>
+emitWitnessTablePack(IRGenFunction &IGF, CanPackType packType,
+                     PackConformance *conformance);
 
 llvm::Value *emitWitnessTablePackRef(IRGenFunction &IGF, CanPackType packType,
                                      PackConformance *conformance);
 
 void cleanupWitnessTablePack(IRGenFunction &IGF, StackAddress pack,
-                             Optional<unsigned> elementCount);
+                             llvm::Value *shape);
 
 /// Emit the dynamic index of a particular structural component
 /// of the given pack type.  If the component is a pack expansion, this

lib/IRGen/MetadataRequest.cpp

@@ -1233,7 +1233,10 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
 
     // Otherwise, we know that either statically or dynamically, we have more than
     // one element. Emit the pack.
-    auto addr = emitTypeMetadataPack(IGF, packType, MetadataState::Abstract);
+    llvm::Value *shape;
+    StackAddress addr;
+    std::tie(addr, shape) =
+        emitTypeMetadataPack(IGF, packType, MetadataState::Abstract);
 
     auto *pointerToFirst = IGF.Builder.CreatePointerCast(
         addr.getAddressPointer(), IGF.IGM.TypeMetadataPtrPtrTy);
@@ -1252,12 +1255,7 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
     call->setCallingConv(IGF.IGM.SwiftCC);
     call->setDoesNotThrow();
 
-    // Clean up the pack.
-    Optional<unsigned> elementCount = 0;
-    if (auto *constant = dyn_cast<llvm::ConstantInt>(shapeExpression))
-      elementCount = constant->getValue().getZExtValue();
-
-    cleanupTypeMetadataPack(IGF, addr, elementCount);
+    cleanupTypeMetadataPack(IGF, addr, shape);
   }
 
   // Control flow join with the one-element case.