Merge pull request #67573 from slavapestov/dynamic-tuple-labels

IRGen: Support tuple labels in emitDynamicTupleTypeMetadataRef()

Author: slavapestov

lib/IRGen/GenPack.cpp

@@ -26,6 +26,7 @@
 #include "swift/SIL/SILType.h"
 #include "llvm/IR/DerivedTypes.h"
 
+#include "GenTuple.h"
 #include "GenType.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -1184,3 +1185,167 @@ void irgen::deallocatePack(IRGenFunction &IGF, StackAddress addr, CanSILPackType
   IGF.Builder.CreateLifetimeEnd(addr.getAddress(),
                                 elementSize * elementCount);
 }
+
+static unsigned getConstantLabelsLength(CanTupleType type) {
+  unsigned total = 0;
+
+  for (auto elt : type->getElements()) {
+    if (elt.getType()->is<PackExpansionType>()) {
+      assert(!elt.hasName());
+      continue;
+    }
+
+    if (elt.hasName()) {
+      assert(!elt.getType()->is<PackExpansionType>());
+      total += elt.getName().getLength();
+    }
+
+    ++total;
+  }
+
+  return total;
+}
+
+/// Emit the dynamic label string for a tuple type containing pack
+/// expansions.
+///
+/// The basic idea is that the static label string is "stretched out".
+/// Pack expansion elements are unlabeled, so they appear as a single
+/// blank space in the static label string. We replace this with the
+/// appropriate number of blank spaces, given the dynamic length of
+/// the pack.
+llvm::Optional<StackAddress>
+irgen::emitDynamicTupleTypeLabels(IRGenFunction &IGF,
+                                  CanTupleType type,
+                                  CanPackType packType,
+                                  llvm::Value *shapeExpression) {
+  bool hasLabels = false;
+  for (auto elt : type->getElements()) {
+    hasLabels |= elt.hasName();
+  }
+
+  if (!hasLabels)
+    return llvm::None;
+
+  // Elements of pack expansion type are unlabeled, so the length of
+  // the label string is the number of elements in the pack, plus the
+  // sum of the lengths of the labels.
+  llvm::Value *labelLength = llvm::ConstantInt::get(
+      IGF.IGM.SizeTy, getConstantLabelsLength(type));
+  labelLength = IGF.Builder.CreateAdd(shapeExpression, labelLength);
+
+  // Leave root for a null byte at the end.
+  labelLength = IGF.Builder.CreateAdd(labelLength,
+      llvm::ConstantInt::get(IGF.IGM.SizeTy, 1));
+
+  // Allocate space for the label string; we fill it in below.
+  StackAddress labelString = IGF.emitDynamicAlloca(
+                                IGF.IGM.Int8Ty, labelLength,
+                                IGF.IGM.getPointerAlignment(),
+                                /*allowTaskAlloc=*/true);
+
+  // Get the static label string, where each pack expansion is one element.
+  auto *staticLabelString = getTupleLabelsString(IGF.IGM, type);
+
+  // The position in the static label string for to the current element.
+  unsigned staticPosition = 0;
+
+  // The position in the dynamic label string for to the current element.
+  llvm::Value *dynamicPosition = llvm::ConstantInt::get(IGF.IGM.SizeTy, 0);
+
+  // Number of expansions we've seen so far.
+  unsigned numExpansions = 0;
+
+  // Was there at least one label?
+  bool sawLabel = false;
+
+  auto visitFn = [&](CanType eltTy,
+                     unsigned scalarIndex,
+                     llvm::Value *dynamicIndex,
+                     llvm::Value *dynamicLength) {
+    auto elt = type->getElements()[scalarIndex + numExpansions];
+    assert(eltTy == CanType(elt.getType()));
+
+    // The destination address, where we put the current element's label.
+    auto eltAddr = IGF.Builder.CreateArrayGEP(labelString.getAddress(),
+                                              dynamicPosition, Size(1));
+
+    // If we're looking at a pack expansion, insert the appropriate
+    // number of blank spaces in the dynamic label string.
+    if (isa<PackExpansionType>(eltTy)) {
+      assert(!elt.hasName() && "Pack expansions cannot have labels");
+      // Fill the dynamic label string with a blank label for each
+      // dynamic element.
+      IGF.Builder.CreateMemSet(
+          eltAddr, llvm::ConstantInt::get(IGF.IGM.Int8Ty, ' '),
+          dynamicLength);
+
+      // We consumed one static label.
+      staticPosition += 1;
+
+      // We produced some number of dynamic labels.
+      dynamicPosition = IGF.Builder.CreateAdd(dynamicPosition, dynamicLength);
+
+      // We consumed an expansion.
+      numExpansions += 1;
+
+      return;
+    }
+
+    // Otherwise, we have a single scalar element, which deposits a single
+    // label in the dynamic label string.
+    unsigned length = 0;
+
+    // Scalar elements may have labels.
+    if (elt.hasName()) {
+      // Index into the static label string.
+      llvm::Constant *indices[] = {
+        llvm::ConstantInt::get(IGF.IGM.SizeTy, staticPosition)
+      };
+
+      // The source address in the static label string.
+      Address srcAddr(
+          llvm::ConstantExpr::getInBoundsGetElementPtr(
+              IGF.IGM.Int8Ty, staticLabelString,
+              indices),
+          IGF.IGM.Int8Ty, Alignment(1));
+
+      // The number of bytes to copy; add one for the space at the end.
+      length = elt.getName().getLength() + 1;
+
+      // Desposit the label for this element in the dynamic label string.
+      IGF.Builder.CreateMemCpy(eltAddr, srcAddr, Size(length));
+
+      sawLabel = true;
+    } else {
+      length = 1;
+
+      // There is no label. The static label string stores a blank space,
+      // and we need to update the dynamic string for the same.
+      IGF.Builder.CreateStore(
+          llvm::ConstantInt::get(IGF.IGM.Int8Ty, ' '),
+          eltAddr);
+    }
+
+    // We consumed one static label.
+    staticPosition += length;
+
+    // We produced one dynamic label.
+    auto *constant = llvm::ConstantInt::get(IGF.IGM.SizeTy, length);
+    accumulateSum(IGF, dynamicPosition, constant);
+  };
+
+  (void) visitPackExplosion(IGF, packType, visitFn);
+
+  // Null-terminate the dynamic label string.
+  auto eltAddr = IGF.Builder.CreateArrayGEP(labelString.getAddress(),
+                                            dynamicPosition, Size(1));
+  IGF.Builder.CreateStore(
+          llvm::ConstantInt::get(IGF.IGM.Int8Ty, '\0'),
+          eltAddr);
+
+  assert(sawLabel);
+  (void) sawLabel;
+
+  return labelString;
+}

lib/IRGen/GenPack.h

@@ -114,6 +114,12 @@ StackAddress allocatePack(IRGenFunction &IGF, CanSILPackType packType);
 
 void deallocatePack(IRGenFunction &IGF, StackAddress addr, CanSILPackType packType);
 
+llvm::Optional<StackAddress>
+emitDynamicTupleTypeLabels(IRGenFunction &IGF,
+                           CanTupleType tupleType,
+                           CanPackType packType,
+                           llvm::Value *shapeExpression);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/GenTuple.cpp

@@ -643,3 +643,28 @@ irgen::getPhysicalTupleElementStructIndex(IRGenModule &IGM, SILType tupleType,
                                           unsigned fieldNo) {
   FOR_TUPLE_IMPL(IGM, tupleType, getElementStructIndex, fieldNo);
 }
+
+/// Emit a string encoding the labels in the given tuple type.
+llvm::Constant *irgen::getTupleLabelsString(IRGenModule &IGM,
+                                            CanTupleType type) {
+  bool hasLabels = false;
+  llvm::SmallString<128> buffer;
+  for (auto &elt : type->getElements()) {
+    if (elt.hasName()) {
+      hasLabels = true;
+      buffer.append(elt.getName().str());
+    }
+
+    // Each label is space-terminated.
+    buffer += ' ';
+  }
+
+  // If there are no labels, use a null pointer.
+  if (!hasLabels) {
+    return llvm::ConstantPointerNull::get(IGM.Int8PtrTy);
+  }
+
+  // Otherwise, create a new string literal.
+  // This method implicitly adds a null terminator.
+  return IGM.getAddrOfGlobalString(buffer);
+}

lib/IRGen/GenTuple.h

@@ -67,6 +67,11 @@ namespace irgen {
   llvm::Optional<unsigned> getPhysicalTupleElementStructIndex(IRGenModule &IGM,
                                                               SILType tupleType,
                                                               unsigned fieldNo);
+
+  /// Emit a string encoding the labels in the given tuple type.
+  llvm::Constant *getTupleLabelsString(IRGenModule &IGM,
+                                       CanTupleType type);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/MetadataRequest.cpp

@@ -27,6 +27,7 @@
 #include "GenPack.h"
 #include "GenPointerAuth.h"
 #include "GenProto.h"
+#include "GenTuple.h"
 #include "GenType.h"
 #include "GenericArguments.h"
 #include "GenericRequirement.h"
@@ -1135,31 +1136,6 @@ MetadataAccessStrategy irgen::getTypeMetadataAccessStrategy(CanType type) {
   return MetadataAccessStrategy::NonUniqueAccessor;
 }
 
-/// Emit a string encoding the labels in the given tuple type.
-static llvm::Constant *getTupleLabelsString(IRGenModule &IGM,
-                                            CanTupleType type) {
-  bool hasLabels = false;
-  llvm::SmallString<128> buffer;
-  for (auto &elt : type->getElements()) {
-    if (elt.hasName()) {
-      hasLabels = true;
-      buffer.append(elt.getName().str());
-    }
-
-    // Each label is space-terminated.
-    buffer += ' ';
-  }
-
-  // If there are no labels, use a null pointer.
-  if (!hasLabels) {
-    return llvm::ConstantPointerNull::get(IGM.Int8PtrTy);
-  }
-
-  // Otherwise, create a new string literal.
-  // This method implicitly adds a null terminator.
-  return IGM.getAddrOfGlobalString(buffer);
-}
-
 static llvm::Constant *emitEmptyTupleTypeMetadataRef(IRGenModule &IGM) {
   llvm::Constant *fullMetadata = IGM.getEmptyTupleMetadata();
   llvm::Constant *indices[] = {
@@ -1188,6 +1164,8 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
   // "vanishes" and gets unwrapped. This behavior is implemented in both
   // compile-time type substitution, and runtime type metadata instantiation,
   // ensuring consistent behavior.
+  //
+  // FIXME: Inconsistent behavior with one-element labeled tuples.
   if (type->getNumScalarElements() <= 1) {
     ConditionalDominanceScope scope(IGF);
 
@@ -1231,6 +1209,9 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
   {
     ConditionalDominanceScope scope(IGF);
 
+    llvm::Optional<StackAddress> labelString = emitDynamicTupleTypeLabels(
+        IGF, type, packType, shapeExpression);
+
     // Otherwise, we know that either statically or dynamically, we have more than
     // one element. Emit the pack.
     llvm::Value *shape;
@@ -1241,12 +1222,20 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
     auto *pointerToFirst = IGF.Builder.CreatePointerCast(
         addr.getAddressPointer(), IGF.IGM.TypeMetadataPtrPtrTy);
 
+    auto *flags = shapeExpression;
+    if (labelString) {
+      flags = IGF.Builder.CreateOr(flags, llvm::ConstantInt::get(IGF.IGM.SizeTy,
+            TupleTypeFlags().withNonConstantLabels(true).getIntValue()));
+    }
+
     // Call swift_getTupleMetadata().
     llvm::Value *args[] = {
       request.get(IGF),
-      shapeExpression,
+      flags,
       pointerToFirst,
-      getTupleLabelsString(IGF.IGM, type),
+      (labelString
+       ? labelString->getAddress().getAddress()
+       : llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy)),
       llvm::ConstantPointerNull::get(IGF.IGM.WitnessTablePtrTy) // proposed
     };
 
@@ -1256,6 +1245,9 @@ static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
     call->setDoesNotThrow();
 
     cleanupTypeMetadataPack(IGF, addr, shape);
+
+    if (labelString)
+      IGF.emitDeallocateDynamicAlloca(*labelString);
   }
 
   // Control flow join with the one-element case.

test/Interpreter/variadic_generic_tuples.swift

@@ -64,4 +64,26 @@ tuples.test("expandTuple") {
   expandTupleElements(1, "hello", true)
 }
 
+func tupleLabelMix<each T, each U>(t: repeat (each T).Type, u: repeat (each U).Type) -> Any.Type {
+  return (Float, hello: Int, repeat each T, swift: String, repeat each U, Bool, world: UInt8).self
+}
+
+func oneElementLabeledTuple<each T>(t: repeat (each T).Type) -> Any.Type {
+  return (label: Int, repeat each T).self
+}
+
+tuples.test("labels") {
+  expectEqual("(Swift.Float, hello: Swift.Int, swift: Swift.String, Swift.Bool, world: Swift.UInt8)", _typeName(tupleLabelMix()))
+  expectEqual("(Swift.Float, hello: Swift.Int, swift: Swift.String, Swift.Double, Swift.Bool, world: Swift.UInt8)", _typeName(tupleLabelMix(u: Double.self)))
+  expectEqual("(Swift.Float, hello: Swift.Int, swift: Swift.String, Swift.Double, Swift.Int32, Swift.Bool, world: Swift.UInt8)", _typeName(tupleLabelMix(u: Double.self, Int32.self)))
+  expectEqual("(Swift.Float, hello: Swift.Int, Swift.Character, swift: Swift.String, Swift.Double, Swift.Bool, world: Swift.UInt8)", _typeName(tupleLabelMix(t: Character.self, u: Double.self)))
+  expectEqual("(Swift.Float, hello: Swift.Int, Swift.Character, Swift.Substring, swift: Swift.String, Swift.Double, Swift.Int32, Swift.Bool, world: Swift.UInt8)", _typeName(tupleLabelMix(t: Character.self, Substring.self, u: Double.self, Int32.self)))
+
+  // FIXME: One-element labeled tuples
+  expectEqual("Swift.Int", _typeName(oneElementLabeledTuple()))
+
+  expectEqual("(label: Swift.Int, Swift.String)", _typeName(oneElementLabeledTuple(t: String.self)))
+}
+
+
 runAllTests()