Merge pull request #64073 from slavapestov/irgen-variadic-generic-types

Preliminary IRGen support for variadic generic types

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -432,6 +432,9 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// the same shape equivalence class.
   bool haveSameShape(Type type1, Type type2) const;
 
+  /// Returns all unique shape classes defined by this generic signature.
+  SmallVector<CanType, 2> getShapeClasses() const;
+
   /// Get the ordinal of a generic parameter in this generic signature.
   ///
   /// For example, if you have a generic signature for a nested context like:

lib/AST/GenericSignature.cpp

@@ -544,6 +544,19 @@ GenericSignatureImpl::haveSameShape(Type type1, Type type2) const {
   return getRequirementMachine()->haveSameShape(type1, type2);
 }
 
+SmallVector<CanType, 2> GenericSignatureImpl::getShapeClasses() const {
+  SmallSetVector<CanType, 2> result;
+
+  forEachParam([&](GenericTypeParamType *gp, bool canonical) {
+    if (!canonical || !gp->isParameterPack())
+      return;
+
+    result.insert(getReducedShape(gp)->getCanonicalType());
+  });
+
+  return result.takeVector();
+}
+
 unsigned GenericParamKey::findIndexIn(
                       TypeArrayView<GenericTypeParamType> genericParams) const {
   // For depth 0, we have random access. We perform the extra checking so that

lib/IRGen/GenMeta.cpp

@@ -414,6 +414,8 @@ namespace {
     unsigned NumParams = 0;
     unsigned NumRequirements = 0;
     unsigned NumGenericKeyArguments = 0;
+    SmallVector<CanType, 2> ShapeClasses;
+    SmallVector<GenericPackArgument, 2> GenericPackArguments;
 
     GenericSignatureHeaderBuilder(IRGenModule &IGM,
                                   ConstantStructBuilder &builder)
@@ -422,13 +424,26 @@ namespace {
         NumGenericKeyArgumentsPP(builder.addPlaceholderWithSize(IGM.Int16Ty)),
         FlagsPP(builder.addPlaceholderWithSize(IGM.Int16Ty)) {}
 
-    void adjustAfterRequirements(const GenericRequirementsMetadata &info) {
+    void add(const GenericArgumentMetadata &info) {
+      ShapeClasses.append(info.ShapeClasses.begin(),
+                          info.ShapeClasses.end());
+
       NumParams += info.NumParams;
       NumRequirements += info.NumRequirements;
+
+      for (auto pack : info.GenericPackArguments) {
+        // Compute the final index.
+        pack.Index += NumGenericKeyArguments + ShapeClasses.size();
+        GenericPackArguments.push_back(pack);
+      }
+
       NumGenericKeyArguments += info.NumGenericKeyArguments;
     }
 
     void finish(IRGenModule &IGM, ConstantStructBuilder &b) {
+      assert(GenericPackArguments.empty() == ShapeClasses.empty() &&
+             "Can't have one without the other");
+
       assert(NumParams <= UINT16_MAX && "way too generic");
       b.fillPlaceholderWithInt(NumParamsPP, IGM.Int16Ty, NumParams);
 
@@ -438,9 +453,9 @@ namespace {
 
       assert(NumGenericKeyArguments <= UINT16_MAX && "way too generic");
       b.fillPlaceholderWithInt(NumGenericKeyArgumentsPP, IGM.Int16Ty,
-                               NumGenericKeyArguments);
+                               NumGenericKeyArguments + ShapeClasses.size());
 
-      bool hasTypePacks = false;
+      bool hasTypePacks = !GenericPackArguments.empty();
       GenericContextDescriptorFlags flags(hasTypePacks);
       b.fillPlaceholderWithInt(FlagsPP, IGM.Int16Ty,
                                flags.getIntValue());
@@ -495,6 +510,7 @@ namespace {
       asImpl().addGenericParametersHeader();
       asImpl().addGenericParameters();
       asImpl().addGenericRequirements();
+      asImpl().addGenericPackShapeDescriptors();
       asImpl().finishGenericParameters();
     }
 
@@ -512,7 +528,7 @@ namespace {
                                     /*implicit=*/false);
       assert(metadata.NumParams == metadata.NumParamsEmitted &&
              "We can't use implicit GenericParamDescriptors here");
-      SignatureHeader->adjustAfterRequirements(metadata);
+      SignatureHeader->add(metadata);
 
       // Pad the structure up to four bytes for the following requirements.
       addPaddingAfterGenericParamDescriptors(IGM, B,
@@ -524,13 +540,49 @@ namespace {
         irgen::addGenericRequirements(IGM, B,
                             asImpl().getGenericSignature(),
                             asImpl().getGenericSignature().getRequirements());
-      SignatureHeader->adjustAfterRequirements(metadata);
+      SignatureHeader->add(metadata);
     }
 
     void finishGenericParameters() {
       SignatureHeader->finish(IGM, B);
     }
 
+    void addGenericPackShapeDescriptors() {
+      const auto &shapes = SignatureHeader->ShapeClasses;
+      const auto &packArgs = SignatureHeader->GenericPackArguments;
+      assert(shapes.empty() == packArgs.empty() &&
+             "Can't have one without the other");
+
+      // If we don't have any pack arguments, there is nothing to emit.
+      if (packArgs.empty())
+        return;
+
+      // Emit the GenericPackShapeHeader first.
+
+      // NumPacks
+      B.addInt(IGM.Int16Ty, packArgs.size());
+
+      // NumShapes
+      B.addInt(IGM.Int16Ty, shapes.size());
+
+      // Emit each GenericPackShapeDescriptor collected previously.
+      for (const auto &packArg : packArgs) {
+        // Kind
+        B.addInt(IGM.Int16Ty, uint16_t(packArg.Kind));
+
+        // Index
+        B.addInt(IGM.Int16Ty, packArg.Index);
+
+        // ShapeClass
+        auto found = std::find(shapes.begin(), shapes.end(), packArg.ReducedShape);
+        assert(found != shapes.end());
+        B.addInt(IGM.Int16Ty, found - shapes.begin());
+
+        // Unused
+        B.addInt(IGM.Int16Ty, 0);
+      }
+    }
+
     uint8_t getVersion() {
       return 0;
     }
@@ -6061,7 +6113,9 @@ void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
 
 static GenericParamDescriptor
 getGenericParamDescriptor(GenericTypeParamType *param, bool canonical) {
-  return GenericParamDescriptor(GenericParamKind::Type,
+  return GenericParamDescriptor(param->isParameterPack()
+                                ? GenericParamKind::TypePack
+                                : GenericParamKind::Type,
                                 /*key argument*/ canonical);
 }
 
@@ -6077,13 +6131,13 @@ static bool canUseImplicitGenericParamDescriptors(CanGenericSignature sig) {
   return allImplicit && count <= MaxNumImplicitGenericParamDescriptors;
 }
 
-GenericRequirementsMetadata
+GenericArgumentMetadata
 irgen::addGenericParameters(IRGenModule &IGM, ConstantStructBuilder &B,
                             GenericSignature sig, bool implicit) {
   assert(sig);
   auto canSig = sig.getCanonicalSignature();
 
-  GenericRequirementsMetadata metadata;
+  GenericArgumentMetadata metadata;
 
   canSig->forEachParam([&](GenericTypeParamType *param, bool canonical) {
     // Currently, there are only type parameters. The parameter is a key
@@ -6098,6 +6152,19 @@ irgen::addGenericParameters(IRGenModule &IGM, ConstantStructBuilder &B,
 
     ++metadata.NumParams;
 
+    // Only key arguments count toward NumGenericPackArguments.
+    if (descriptor.hasKeyArgument() &&
+        descriptor.getKind() == GenericParamKind::TypePack) {
+      auto reducedShape = canSig->getReducedShape(param)->getCanonicalType();
+      metadata.GenericPackArguments.emplace_back(
+          GenericPackKind::Metadata,
+          metadata.NumGenericKeyArguments,
+          reducedShape);
+
+      if (reducedShape->isEqual(param))
+        metadata.ShapeClasses.push_back(reducedShape);
+    }
+
     if (descriptor.hasKeyArgument())
       ++metadata.NumGenericKeyArguments;
   });
@@ -6121,11 +6188,21 @@ static void addRelativeAddressOfTypeRef(IRGenModule &IGM,
 
 /// Add a generic requirement to the given constant struct builder.
 static void addGenericRequirement(IRGenModule &IGM, ConstantStructBuilder &B,
-                                  GenericRequirementsMetadata &metadata,
+                                  GenericArgumentMetadata &metadata,
                                   GenericSignature sig,
                                   GenericRequirementFlags flags,
                                   Type paramType,
                                   llvm::function_ref<void ()> addReference) {
+  // Only key arguments (ie, conformance requirements) count toward
+  // NumGenericPackArguments.
+  if (flags.hasKeyArgument() && flags.isPackRequirement()) {
+      assert(flags.getKind() == GenericRequirementKind::Protocol);
+      metadata.GenericPackArguments.emplace_back(
+          GenericPackKind::WitnessTable,
+          metadata.NumGenericKeyArguments,
+          sig->getReducedShape(paramType)->getCanonicalType());
+  }
+
   if (flags.hasKeyArgument())
     ++metadata.NumGenericKeyArguments;
 
@@ -6134,13 +6211,13 @@ static void addGenericRequirement(IRGenModule &IGM, ConstantStructBuilder &B,
   addReference();
 }
 
-GenericRequirementsMetadata irgen::addGenericRequirements(
+GenericArgumentMetadata irgen::addGenericRequirements(
                                    IRGenModule &IGM, ConstantStructBuilder &B,
                                    GenericSignature sig,
                                    ArrayRef<Requirement> requirements) {
   assert(sig);
 
-  GenericRequirementsMetadata metadata;
+  GenericArgumentMetadata metadata;
   for (auto &requirement : requirements) {
     auto kind = requirement.getKind();
     bool isPackRequirement = requirement.getFirstType()->isParameterPack();
@@ -6504,7 +6581,7 @@ irgen::emitExtendedExistentialTypeShape(IRGenModule &IGM,
                                    GenericSignatureHeaderBuilder &header,
                                    bool implicit) {
       auto info = irgen::addGenericParameters(IGM, b, sig, implicit);
-      header.adjustAfterRequirements(info);
+      header.add(info);
       totalParamDescriptors += info.NumParamsEmitted;
     };
     addParamDescriptors(reqSig, reqHeader, flags.hasImplicitReqSigParams());
@@ -6516,7 +6593,7 @@ irgen::emitExtendedExistentialTypeShape(IRGenModule &IGM,
     auto addRequirementDescriptors = [&](CanGenericSignature sig,
                                       GenericSignatureHeaderBuilder &header) {
       auto info = addGenericRequirements(IGM, b, sig, sig.getRequirements());
-      header.adjustAfterRequirements(info);
+      header.add(info);
       header.finish(IGM, b);
     };
 
@@ -6526,6 +6603,15 @@ irgen::emitExtendedExistentialTypeShape(IRGenModule &IGM,
       addRequirementDescriptors(genSig, *genHeader);
     }
 
+    // The 'Self' parameter in an existential is not variadic
+    assert(reqHeader.GenericPackArguments.empty() &&
+           "Generic parameter packs should not ever appear here");
+
+    // You can have a superclass with a generic parameter pack in a composition,
+    // like `C<each T> & P<Int>`
+    assert(genHeader->GenericPackArguments.empty() &&
+           "Generic parameter packs not supported here yet");
+
     return b.finishAndCreateFuture();
   }, [&](llvm::GlobalVariable *var) {
     var->setConstant(true);

lib/IRGen/GenMeta.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_IRGEN_GENMETA_H
 #define SWIFT_IRGEN_GENMETA_H
 
+#include "swift/ABI/MetadataValues.h"
 #include <utility>
 
 namespace llvm {
@@ -169,18 +170,31 @@ namespace irgen {
   void getArgAsLocalSelfTypeMetadata(IRGenFunction &IGF, llvm::Value *arg,
                                      CanType abstractType);
 
+  struct GenericPackArgument {
+    GenericPackKind Kind;
+    unsigned Index;
+    CanType ReducedShape;
+
+    GenericPackArgument(GenericPackKind kind,
+                        unsigned index,
+                        CanType reducedShape)
+      : Kind(kind), Index(index), ReducedShape(reducedShape) {}
+  };
+
   /// Description of the metadata emitted by adding generic requirements.
-  struct GenericRequirementsMetadata {
+  struct GenericArgumentMetadata {
     unsigned NumParams = 0;
     unsigned NumParamsEmitted = 0;
     unsigned NumRequirements = 0;
     unsigned NumGenericKeyArguments = 0;
+    SmallVector<CanType, 1> ShapeClasses;
+    SmallVector<GenericPackArgument, 1> GenericPackArguments;
   };
 
   /// Add generic parameters to the given constant struct builder.
   ///
   /// \param sig The generic signature whose parameters we wish to emit.
-  GenericRequirementsMetadata addGenericParameters(
+  GenericArgumentMetadata addGenericParameters(
                                           IRGenModule &IGM,
                                           ConstantStructBuilder &B,
                                           GenericSignature sig,
@@ -192,7 +206,7 @@ namespace irgen {
   /// described.
   ///
   /// \param requirements The requirements to add.
-  GenericRequirementsMetadata addGenericRequirements(
+  GenericArgumentMetadata addGenericRequirements(
                                           IRGenModule &IGM,
                                           ConstantStructBuilder &B,
                                           GenericSignature sig,

lib/IRGen/GenPack.cpp

@@ -458,6 +458,8 @@ irgen::emitTypeMetadataPackRef(IRGenFunction &IGF, CanPackType packType,
 
   auto pack = emitTypeMetadataPack(IGF, packType, request);
   auto *metadata = pack.getAddress().getAddress();
+  metadata = IGF.Builder.CreatePointerCast(
+      metadata, IGF.IGM.TypeMetadataPtrTy->getPointerTo());
 
   auto response = MetadataResponse::forComplete(metadata);
   IGF.setScopedLocalTypeMetadata(packType, response);
@@ -612,6 +614,8 @@ llvm::Value *irgen::emitWitnessTablePackRef(IRGenFunction &IGF,
   auto pack = emitWitnessTablePack(IGF, packType, conformance);
 
   auto *result = pack.getAddress().getAddress();
+  result = IGF.Builder.CreatePointerCast(
+      result, IGF.IGM.WitnessTablePtrTy->getPointerTo());
 
   IGF.setScopedLocalTypeData(packType, localDataKind, result);
 

lib/IRGen/GenProto.cpp

@@ -258,15 +258,7 @@ irgen::enumerateGenericSignatureRequirements(CanGenericSignature signature,
                                           const RequirementCallback &callback) {
   if (!signature) return;
 
-  // Get all unique pack generic parameter shapes.
-  SmallSetVector<CanType, 2> packs;
-  for (auto gp : signature.getGenericParams()) {
-    if (gp->isParameterPack()) {
-      packs.insert(signature->getReducedShape(gp)->getCanonicalType());
-    }
-  }
-
-  for (auto type : packs)
+  for (auto type : signature->getShapeClasses())
     callback(GenericRequirement::forShape(type));
 
   // Get all of the type metadata.
@@ -4087,6 +4079,8 @@ llvm::Constant *IRGenModule::getAddrOfGenericEnvironment(
             irgen::addGenericParameters(*this, fields, signature, /*implicit=*/false);
         assert(metadata.NumParamsEmitted == metadata.NumParams &&
                "Implicit GenericParamDescriptors not supported here");
+        assert(metadata.GenericPackArguments.empty() &&
+               "We don't support packs here yet");
 
         // Need to pad the structure after generic parameters
         // up to four bytes because generic requirements that

lib/IRGen/MetadataRequest.cpp

@@ -1288,7 +1288,7 @@ static Address createGenericArgumentsArray(IRGenFunction &IGF,
   for (unsigned i : indices(args)) {
     Address elt = IGF.Builder.CreateStructGEP(argsBuffer, i,
                                               IGF.IGM.getPointerSize() * i);
-    auto *arg = IGF.Builder.CreateBitCast(args[i], IGF.IGM.Int8PtrTy);
+    auto *arg = IGF.Builder.CreateBitOrPointerCast(args[i], IGF.IGM.Int8PtrTy);
     IGF.Builder.CreateStore(arg, elt);
   }