IRGen: Support for tuple metadata involving pack expansions

Author: slavapestov

lib/IRGen/GenPack.cpp

@@ -133,9 +133,6 @@ static Address emitFixedSizeMetadataPackRef(IRGenFunction &IGF,
   pack = IGF.Builder.CreateConstArrayGEP(
       pack, 0, IGF.IGM.getPointerSize());
 
-  IGF.Builder.CreateLifetimeStart(
-      pack, Size(IGF.IGM.getPointerSize() * elementCount));
-
   return pack;
 }
 

lib/IRGen/MetadataRequest.cpp

@@ -1136,13 +1136,7 @@ MetadataAccessStrategy irgen::getTypeMetadataAccessStrategy(CanType type) {
 
 /// Emit a string encoding the labels in the given tuple type.
 static llvm::Constant *getTupleLabelsString(IRGenModule &IGM,
-                                            CanTupleType type,
-                                            bool useLabels) {
-  // If we were asked to ignore the labels, do so.
-  if (!useLabels) {
-    return llvm::ConstantPointerNull::get(IGM.Int8PtrTy);
-  }
-
+                                            CanTupleType type) {
   bool hasLabels = false;
   llvm::SmallString<128> buffer;
   for (auto &elt : type->getElements()) {
@@ -1175,21 +1169,55 @@ static llvm::Constant *emitEmptyTupleTypeMetadataRef(IRGenModule &IGM) {
       IGM.FullTypeMetadataStructTy, fullMetadata, indices);
 }
 
-using GetElementMetadataFn =
-  llvm::function_ref<MetadataResponse(CanType eltType,
-                                      DynamicMetadataRequest eltRequest)>;
+static MetadataResponse emitDynamicTupleTypeMetadataRef(IRGenFunction &IGF,
+                                                        CanTupleType type,
+                                                        DynamicMetadataRequest request) {
+  SmallVector<Type, 2> types;
+  types.append(type.getElementTypes().begin(),
+               type.getElementTypes().end());
+
+  CanPackType packType = CanPackType(PackType::get(IGF.IGM.Context, types));
+
+  auto *shapeExpression = IGF.emitPackShapeExpression(packType);
+  auto addr = emitTypeMetadataPack(IGF, packType, MetadataState::Abstract);
+
+  auto *pointerToFirst = IGF.Builder.CreatePointerCast(
+      addr.getAddressPointer(), IGF.IGM.TypeMetadataPtrPtrTy);
+
+  llvm::Value *args[] = {
+    request.get(IGF),
+    shapeExpression,
+    pointerToFirst,
+    getTupleLabelsString(IGF.IGM, type),
+    llvm::ConstantPointerNull::get(IGF.IGM.WitnessTablePtrTy) // proposed
+  };
+
+  auto call = IGF.Builder.CreateCall(
+      IGF.IGM.getGetTupleMetadataFunctionPointer(), args);
+  call->setCallingConv(IGF.IGM.SwiftCC);
+  call->setDoesNotThrow();
+
+  Optional<unsigned> elementCount = 0;
+  if (auto *constant = dyn_cast<llvm::ConstantInt>(shapeExpression))
+    elementCount = constant->getValue().getZExtValue();
+
+  cleanupTypeMetadataPack(IGF, addr, elementCount);
+
+  return MetadataResponse::handle(IGF, request, call);
+}
 
 static MetadataResponse emitTupleTypeMetadataRef(IRGenFunction &IGF,
                                                  CanTupleType type,
-                                                 DynamicMetadataRequest request,
-                                                 bool useLabels,
-                                    GetElementMetadataFn getMetadataRecursive) {
+                                                 DynamicMetadataRequest request) {
+  if (type->containsPackExpansionType())
+    return emitDynamicTupleTypeMetadataRef(IGF, type, request);
+
   auto getElementMetadata = [&](CanType type) {
     // Just request the elements to be abstract so that we can always build
     // the metadata.
     // TODO: if we have a collector, or if this is a blocking request, maybe
     // we should build a stronger request?
-    return getMetadataRecursive(type, MetadataState::Abstract).getMetadata();
+    return IGF.emitTypeMetadataRef(type, MetadataState::Abstract).getMetadata();
   };
 
   switch (type->getNumElements()) {
@@ -1200,7 +1228,7 @@ static MetadataResponse emitTupleTypeMetadataRef(IRGenFunction &IGF,
   case 1:
     // For metadata purposes, we consider a singleton tuple to be
     // isomorphic to its element type. ???
-    return getMetadataRecursive(type.getElementType(0), request);
+    return IGF.emitTypeMetadataRef(type.getElementType(0), request);
 
   case 2: {
     auto elt0Metadata = getElementMetadata(type.getElementType(0));
@@ -1209,7 +1237,7 @@ static MetadataResponse emitTupleTypeMetadataRef(IRGenFunction &IGF,
     llvm::Value *args[] = {
       request.get(IGF),
       elt0Metadata, elt1Metadata,
-      getTupleLabelsString(IGF.IGM, type, useLabels),
+      getTupleLabelsString(IGF.IGM, type),
       llvm::ConstantPointerNull::get(IGF.IGM.WitnessTablePtrTy) // proposed
     };
 
@@ -1229,7 +1257,7 @@ static MetadataResponse emitTupleTypeMetadataRef(IRGenFunction &IGF,
     llvm::Value *args[] = {
       request.get(IGF),
       elt0Metadata, elt1Metadata, elt2Metadata,
-      getTupleLabelsString(IGF.IGM, type, useLabels),
+      getTupleLabelsString(IGF.IGM, type),
       llvm::ConstantPointerNull::get(IGF.IGM.WitnessTablePtrTy) // proposed
     };
 
@@ -1241,50 +1269,7 @@ static MetadataResponse emitTupleTypeMetadataRef(IRGenFunction &IGF,
     return MetadataResponse::handle(IGF, request, call);
   }
   default:
-    // TODO: use a caching entrypoint (with all information
-    // out-of-line) for non-dependent tuples.
-
-    llvm::Value *pointerToFirst = nullptr; // appease -Wuninitialized
-
-    auto elements = type.getElementTypes();
-    auto arrayTy = llvm::ArrayType::get(IGF.IGM.TypeMetadataPtrTy,
-                                        elements.size());
-    Address buffer = IGF.createAlloca(arrayTy,IGF.IGM.getPointerAlignment(),
-                                      "tuple-elements");
-    IGF.Builder.CreateLifetimeStart(buffer,
-                                IGF.IGM.getPointerSize() * elements.size());
-    for (auto i : indices(elements)) {
-      // Find the metadata pointer for this element.
-      llvm::Value *eltMetadata = getElementMetadata(elements[i]);
-
-      // GEP to the appropriate element and store.
-      Address eltPtr = IGF.Builder.CreateStructGEP(buffer, i,
-                                                 IGF.IGM.getPointerSize());
-      IGF.Builder.CreateStore(eltMetadata, eltPtr);
-
-      // Remember the GEP to the first element.
-      if (i == 0) pointerToFirst = eltPtr.getAddress();
-    }
-
-    TupleTypeFlags flags =
-      TupleTypeFlags().withNumElements(elements.size());
-    llvm::Value *args[] = {
-      request.get(IGF),
-      llvm::ConstantInt::get(IGF.IGM.SizeTy, flags.getIntValue()),
-      pointerToFirst,
-      getTupleLabelsString(IGF.IGM, type, useLabels),
-      llvm::ConstantPointerNull::get(IGF.IGM.WitnessTablePtrTy) // proposed
-    };
-
-    auto call = IGF.Builder.CreateCall(
-        IGF.IGM.getGetTupleMetadataFunctionPointer(), args);
-    call->setCallingConv(IGF.IGM.SwiftCC);
-    call->setDoesNotThrow();
-
-    IGF.Builder.CreateLifetimeEnd(buffer,
-                                IGF.IGM.getPointerSize() * elements.size());
-
-    return MetadataResponse::handle(IGF, request, call);
+    return emitDynamicTupleTypeMetadataRef(IGF, type, request);
   }
 }
 
@@ -1442,11 +1427,7 @@ namespace {
       if (auto cached = tryGetLocal(type, request))
         return cached;
 
-      auto response = emitTupleTypeMetadataRef(IGF, type, request,
-                                               /*labels*/ true,
-          [&](CanType eltType, DynamicMetadataRequest eltRequest) {
-        return IGF.emitTypeMetadataRef(eltType, eltRequest);
-      });
+      auto response = emitTupleTypeMetadataRef(IGF, type, request);
 
       return setLocal(type, response);
     }

test/IRGen/variadic_generic_types.swift

@@ -16,13 +16,21 @@ struct G<T...> {
   func caller() {
     callee()
   }
+
+  func makeTuple1() -> (T...).Type {
+    return (T...).self
+  }
+
+  func makeTuple2() -> ((Array<T>)...).Type {
+    return ((Array<T>)...).self
+  }
 }
 
 func blackHole<T>(_: T) {}
 
 blackHole(G< >.self)
 blackHole(G<Int, String>.self)
 
-func genericMetadata<T...>(_: T...) {
-  blackHole(G<T... >.self)
-}
+let g = G<Int, String, Float>()
+blackHole(g.makeTuple1())
+blackHole(g.makeTuple2())

test/Interpreter/variadic_generic_types.swift

@@ -0,0 +1,15 @@
+// RUN: %target-run-simple-swift(-enable-experimental-feature VariadicGenerics) | %FileCheck %s
+
+// REQUIRES: executable_test
+
+// Because of -enable-experimental-feature VariadicGenerics
+// REQUIRES: asserts
+
+struct G<T...> {
+  func makeTuple() {
+    print(((Array<T>)...).self)
+  }
+}
+
+// CHECK: (Array<Int>, Array<String>, Array<Float>)
+G<Int, String, Float>().makeTuple()