SIL: Track local environments instead of root local archetypes

Author: slavapestov

include/swift/SIL/SILInstruction.h

@@ -722,8 +722,8 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Run the given function for each local archetype this instruction
   /// defines, passing the value that should be used to record the
   /// dependency.
-  void forEachDefinedLocalArchetype(
-      llvm::function_ref<void(CanLocalArchetypeType archetype,
+  void forEachDefinedLocalEnvironment(
+      llvm::function_ref<void(GenericEnvironment *genericEnv,
                               SILValue typeDependency)> function) const;
   bool definesLocalArchetypes() const;
 
@@ -8194,8 +8194,8 @@ class OpenPackElementInst final
 public:
   /// Call the given function for each element archetype that this
   /// instruction opens.
-  void forEachDefinedLocalArchetype(
-      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const;
+  void forEachDefinedLocalEnvironment(
+      llvm::function_ref<void(GenericEnvironment *, SILValue)> fn) const;
 
   GenericEnvironment *getOpenedGenericEnvironment() const {
     return Env;

include/swift/SIL/SILModule.h

@@ -343,18 +343,18 @@ class SILModule {
   /// projections, shared between all functions in the module.
   std::unique_ptr<IndexTrieNode> indexTrieRoot;
 
-  /// A mapping from root local archetypes to the instructions which define
+  /// A mapping from local generic environments to the instructions which define
   /// them.
   ///
   /// The value is either a SingleValueInstruction or a PlaceholderValue,
   /// in case a local archetype definition is looked up during parsing or
   /// deserializing SIL, where local archetypes can be forward referenced.
   ///
   /// In theory we wouldn't need to have the SILFunction in the key, because
-  /// local archetypes \em should be unique across the module. But currently
+  /// local environments should be unique across the module. But currently
   /// in some rare cases SILGen re-uses the same local archetype for multiple
   /// functions.
-  using LocalArchetypeKey = std::pair<LocalArchetypeType *, SILFunction *>;
+  using LocalArchetypeKey = std::pair<GenericEnvironment *, SILFunction *>;
   llvm::DenseMap<LocalArchetypeKey, SILValue> RootLocalArchetypeDefs;
 
   /// The number of PlaceholderValues in RootLocalArchetypeDefs.
@@ -451,6 +451,15 @@ class SILModule {
     hasAccessMarkerHandler = true;
   }
 
+  /// Returns the instruction which defines the given local generic environment,
+  /// e.g. an open_existential_addr.
+  ///
+  /// In case the generic environment is not defined yet (e.g. during parsing or
+  /// deserialization), a PlaceholderValue is returned. This should not be the
+  /// case outside of parsing or deserialization.
+  SILValue getLocalGenericEnvironmentDef(GenericEnvironment *genericEnv,
+                                         SILFunction *inFunction);
+
   /// Returns the instruction which defines the given root local archetype,
   /// e.g. an open_existential_addr.
   ///

lib/SIL/IR/SILInstruction.cpp

@@ -1676,22 +1676,21 @@ const ValueBase *SILInstructionResultArray::back() const {
 
 bool SILInstruction::definesLocalArchetypes() const {
   bool definesAny = false;
-  forEachDefinedLocalArchetype([&](CanLocalArchetypeType type,
-                                   SILValue dependency) {
+  forEachDefinedLocalEnvironment([&](GenericEnvironment *genericEnv,
+                                     SILValue dependency) {
     definesAny = true;
   });
   return definesAny;
 }
 
-void SILInstruction::forEachDefinedLocalArchetype(
-      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const {
+void SILInstruction::forEachDefinedLocalEnvironment(
+      llvm::function_ref<void(GenericEnvironment *, SILValue)> fn) const {
   switch (getKind()) {
 #define SINGLE_VALUE_SINGLE_OPEN(TYPE)                                    \
   case SILInstructionKind::TYPE: {                                        \
     auto I = cast<TYPE>(this);                                            \
     auto archetype = I->getDefinedOpenedArchetype();                      \
-    assert(archetype);                                                    \
-    return fn(archetype, I);                                              \
+    return fn(archetype->getGenericEnvironment(), I);                     \
   }
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialAddrInst)
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialRefInst)
@@ -1700,22 +1699,15 @@ void SILInstruction::forEachDefinedLocalArchetype(
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialMetatypeInst)
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialValueInst)
 #undef SINGLE_VALUE_SINGLE_OPEN
-  case SILInstructionKind::OpenPackElementInst:
-    return cast<OpenPackElementInst>(this)->forEachDefinedLocalArchetype(fn);
+  case SILInstructionKind::OpenPackElementInst: {
+    auto I = cast<OpenPackElementInst>(this);
+    return fn(I->getOpenedGenericEnvironment(), I);
+  }
   default:
     return;
   }
 }
 
-void OpenPackElementInst::forEachDefinedLocalArchetype(
-      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const {
-  getOpenedGenericEnvironment()->forEachPackElementBinding(
-                                  [&](ElementArchetypeType *elementType,
-                                      PackType *packSubstitution) {
-    fn(CanElementArchetypeType(elementType), this);
-  });
-}
-
 //===----------------------------------------------------------------------===//
 //                         Multiple Value Instruction
 //===----------------------------------------------------------------------===//

lib/SIL/IR/SILInstructions.cpp

@@ -47,7 +47,7 @@ static void *allocateTrailingInst(SILFunction &F, CountTypes... counts) {
 
 namespace {
 class TypeDependentOperandCollector {
-  SmallVector<CanLocalArchetypeType, 4> rootLocalArchetypes;
+  SmallVector<GenericEnvironment *, 4> genericEnvs;
   bool hasDynamicSelf = false;
 public:
   void collect(CanType type);
@@ -86,15 +86,15 @@ void TypeDependentOperandCollector::collect(CanType type) {
     return;
   type.visit([&](CanType t) {
     if (const auto local = dyn_cast<LocalArchetypeType>(t)) {
-      const auto root = local.getRoot();
+      auto *genericEnv = local->getGenericEnvironment();
 
-      // Add this root local archetype if it was not seen yet.
+      // Add this local archetype's environment if it was not seen yet.
       // We don't use a set here, because the number of open archetypes
       // is usually very small and using a real set may introduce too
       // much overhead.
-      if (std::find(rootLocalArchetypes.begin(), rootLocalArchetypes.end(),
-                    root) == rootLocalArchetypes.end())
-        rootLocalArchetypes.push_back(root);
+      if (std::find(genericEnvs.begin(), genericEnvs.end(),
+                    genericEnv) == genericEnvs.end())
+        genericEnvs.push_back(genericEnv);
     }
   });
 }
@@ -113,20 +113,11 @@ void TypeDependentOperandCollector::collect(SubstitutionMap subs) {
 /// for those dependencies to the given vector.
 void TypeDependentOperandCollector::addTo(SmallVectorImpl<SILValue> &operands,
                                           SILFunction &F) {
-  size_t firstArchetypeOperand = operands.size();
-  for (CanLocalArchetypeType archetype : rootLocalArchetypes) {
-    SILValue def = F.getModule().getRootLocalArchetypeDef(archetype, &F);
+  for (GenericEnvironment *genericEnv : genericEnvs) {
+    SILValue def = F.getModule().getLocalGenericEnvironmentDef(genericEnv, &F);
     assert(def->getFunction() == &F &&
-           "def of root local archetype is in wrong function");
-
-    // The archetypes in rootLocalArchetypes have already been uniqued,
-    // but a single instruction can open multiple archetypes (e.g.
-    // open_pack_element), so we also unique the actual operand values.
-    // As above, we assume there are very few values in practice and so
-    // a linear scan is better than maintaining a set.
-    if (std::find(operands.begin() + firstArchetypeOperand, operands.end(),
-                  def) == operands.end())
-      operands.push_back(def);
+           "def of local environment is in wrong function");
+    operands.push_back(def);
   }
   if (hasDynamicSelf)
     operands.push_back(F.getDynamicSelfMetadata());

lib/SIL/IR/SILModule.cpp

@@ -208,9 +208,9 @@ void *SILModule::allocateInst(unsigned Size, unsigned Align) const {
 
 void SILModule::willDeleteInstruction(SILInstruction *I) {
   // Update RootLocalArchetypeDefs.
-  I->forEachDefinedLocalArchetype([&](CanLocalArchetypeType archeTy,
-                                      SILValue dependency) {
-    LocalArchetypeKey key = {archeTy, I->getFunction()};
+  I->forEachDefinedLocalEnvironment([&](GenericEnvironment *genericEnv,
+                                        SILValue dependency) {
+    LocalArchetypeKey key = {genericEnv, I->getFunction()};
     // In case `willDeleteInstruction` is called twice for the
     // same instruction, we need to check if the archetype is really
     // still in the map for this instruction.
@@ -674,20 +674,25 @@ void SILModule::registerDeserializationNotificationHandler(
   deserializationNotificationHandlers.add(std::move(handler));
 }
 
-SILValue SILModule::getRootLocalArchetypeDef(CanLocalArchetypeType archetype,
-                                             SILFunction *inFunction) {
-  assert(archetype->isRoot());
-
-  SILValue &def = RootLocalArchetypeDefs[{archetype, inFunction}];
+SILValue SILModule::getLocalGenericEnvironmentDef(GenericEnvironment *genericEnv,
+                                                  SILFunction *inFunction) {
+  SILValue &def = RootLocalArchetypeDefs[{genericEnv, inFunction}];
   if (!def) {
     numUnresolvedLocalArchetypes++;
     def = ::new PlaceholderValue(inFunction,
-                                 SILType::getPrimitiveAddressType(archetype));
+                                 SILType::getPrimitiveAddressType(
+                                    inFunction->getASTContext().TheEmptyTupleType));
   }
 
   return def;
 }
 
+SILValue SILModule::getRootLocalArchetypeDef(CanLocalArchetypeType archetype,
+                                             SILFunction *inFunction) {
+  return getLocalGenericEnvironmentDef(archetype->getGenericEnvironment(),
+                                       inFunction);
+}
+
 void SILModule::reclaimUnresolvedLocalArchetypeDefinitions() {
   llvm::DenseMap<LocalArchetypeKey, SILValue> newLocalArchetypeDefs;
 
@@ -757,21 +762,21 @@ unsigned SILModule::getCaseIndex(EnumElementDecl *enumElement) {
 }
 
 void SILModule::notifyAddedInstruction(SILInstruction *inst) {
-  inst->forEachDefinedLocalArchetype([&](CanLocalArchetypeType archeTy,
-                                         SILValue dependency) {
-    SILValue &val = RootLocalArchetypeDefs[{archeTy, inst->getFunction()}];
+  inst->forEachDefinedLocalEnvironment([&](GenericEnvironment *genericEnv,
+                                           SILValue dependency) {
+    SILValue &val = RootLocalArchetypeDefs[{genericEnv, inst->getFunction()}];
     if (val) {
       if (!isa<PlaceholderValue>(val)) {
         // Print a useful error message (and not just abort with an assert).
-        llvm::errs() << "re-definition of root local archetype in function "
+        llvm::errs() << "re-definition of local environment in function "
                      << inst->getFunction()->getName() << ":\n";
         inst->print(llvm::errs());
         llvm::errs() << "previously defined in function "
                      << val->getFunction()->getName() << ":\n";
         val->print(llvm::errs());
         abort();
       }
-      // The local archetype was unresolved so far. Replace the placeholder
+      // The local environment was unresolved so far. Replace the placeholder
       // by inst.
       auto *placeholder = cast<PlaceholderValue>(val);
       placeholder->replaceAllUsesWith(dependency);
@@ -792,13 +797,13 @@ void SILModule::notifyMovedInstruction(SILInstruction *inst,
     }
   }
 
-  inst->forEachDefinedLocalArchetype([&](CanLocalArchetypeType archeTy,
-                                         SILValue dependency) {
-    LocalArchetypeKey key = {archeTy, fromFunction};
+  inst->forEachDefinedLocalEnvironment([&](GenericEnvironment *genericEnv,
+                                           SILValue dependency) {
+    LocalArchetypeKey key = {genericEnv, fromFunction};
     assert(RootLocalArchetypeDefs.lookup(key) == dependency &&
            "archetype def was not registered");
     RootLocalArchetypeDefs.erase(key);
-    RootLocalArchetypeDefs[{archeTy, inst->getFunction()}] = dependency;
+    RootLocalArchetypeDefs[{genericEnv, inst->getFunction()}] = dependency;
   });
 }
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -1944,8 +1944,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                 "archetype from the substitutions list");
 
         bool matchedDependencyResult = false;
-        DI->forEachDefinedLocalArchetype(
-            [&](CanLocalArchetypeType archetype, SILValue dependency) {
+        DI->forEachDefinedLocalEnvironment(
+            [&](GenericEnvironment *genericEnv, SILValue dependency) {
           if (dependency == V)
             matchedDependencyResult = true;
         });