[NFC] Support instructions that define multiple opened archetypes

rjmccall · rjmccall · commit f524f3de69ea · 2022-12-13T13:28:13.000-05:00
I've also fixed this so that it should work on instructions that
define multiple values.  Someday we'll change all the open_existential
instructions to produce different values for the type dependency and
the value result; today is not that day, though.
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -685,6 +685,14 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
     return getResultsImpl().getTypes();
   }
 
+  /// Run the given function for each opened archetype this instruction
+  /// defines, passing the value that should be used to record the
+  /// dependency.
+  void forEachDefinedOpenedArchetype(
+      llvm::function_ref<void(CanOpenedArchetypeType archetype,
+                              SILValue typeDependency)> function) const;
+  bool definesOpenedArchetypes() const;
+
   MemoryBehavior getMemoryBehavior() const;
   ReleasingBehavior getReleasingBehavior() const;
 
@@ -1096,10 +1104,6 @@ class SingleValueInstruction : public SILInstruction, public ValueBase {
            node->getKind() <= SILNodeKind::Last_SingleValueInstruction;
   }
 
-  /// If this is an instruction which "defines" a root opened archetype, it is
-  /// returned.
-  CanOpenedArchetypeType getDefinedOpenedArchetype() const;
-
   SILInstruction *getPreviousInstruction() {
     return SILInstruction::getPreviousInstruction();
   }
@@ -7137,6 +7141,13 @@ class OpenExistentialAddrInst
   }
 
   OpenedExistentialAccess getAccessKind() const { return ForAccess; }
+
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given an opaque value referring to an existential, "opens" the
@@ -7150,6 +7161,14 @@ class OpenExistentialValueInst
   OpenExistentialValueInst(SILDebugLocation debugLoc, SILValue operand,
                            SILType selfTy,
                            ValueOwnershipKind forwardingOwnershipKind);
+
+public:
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given a class existential, "opens" the
@@ -7163,6 +7182,14 @@ class OpenExistentialRefInst
   OpenExistentialRefInst(SILDebugLocation DebugLoc, SILValue Operand,
                          SILType Ty,
                          ValueOwnershipKind forwardingOwnershipKind);
+
+public:
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given an existential metatype,
@@ -7177,6 +7204,14 @@ class OpenExistentialMetatypeInst
 
   OpenExistentialMetatypeInst(SILDebugLocation DebugLoc, SILValue operand,
                               SILType ty);
+
+public:
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given a boxed existential container,
@@ -7190,6 +7225,14 @@ class OpenExistentialBoxInst
 
   OpenExistentialBoxInst(SILDebugLocation DebugLoc, SILValue operand,
                          SILType ty);
+
+public:
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given a boxed existential container, "opens" the existential by returning a
@@ -7203,6 +7246,14 @@ class OpenExistentialBoxValueInst
   OpenExistentialBoxValueInst(SILDebugLocation DebugLoc, SILValue operand,
                               SILType ty,
                               ValueOwnershipKind forwardingOwnershipKind);
+
+public:
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const {
+    const auto archetype = getOpenedArchetypeOf(getType().getASTType());
+    assert(archetype && archetype->isRoot() &&
+           "Type should be a root opened archetype");
+    return archetype;
+  }
 };
 
 /// Given an address to an uninitialized buffer of
diff --git a/lib/SIL/IR/SILInstruction.cpp b/lib/SIL/IR/SILInstruction.cpp
@@ -1528,24 +1528,37 @@ const ValueBase *SILInstructionResultArray::back() const {
 }
 
 //===----------------------------------------------------------------------===//
-//                           SingleValueInstruction
+//                          Defined opened archetypes
 //===----------------------------------------------------------------------===//
 
-CanOpenedArchetypeType
-SingleValueInstruction::getDefinedOpenedArchetype() const {
+bool SILInstruction::definesOpenedArchetypes() const {
+  bool definesAny = false;
+  forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType type,
+                                    SILValue dependency) {
+    definesAny = true;
+  });
+  return definesAny;
+}
+
+void SILInstruction::forEachDefinedOpenedArchetype(
+      llvm::function_ref<void(CanOpenedArchetypeType, SILValue)> fn) const {
   switch (getKind()) {
-  case SILInstructionKind::OpenExistentialAddrInst:
-  case SILInstructionKind::OpenExistentialRefInst:
-  case SILInstructionKind::OpenExistentialBoxInst:
-  case SILInstructionKind::OpenExistentialBoxValueInst:
-  case SILInstructionKind::OpenExistentialMetatypeInst:
-  case SILInstructionKind::OpenExistentialValueInst: {
-    const auto Ty = getOpenedArchetypeOf(getType().getASTType());
-    assert(Ty && Ty->isRoot() && "Type should be a root opened archetype");
-    return Ty;
+#define SINGLE_VALUE_SINGLE_OPEN(TYPE)                                    \
+  case SILInstructionKind::TYPE: {                                        \
+    auto I = cast<TYPE>(this);                                            \
+    auto archetype = I->getDefinedOpenedArchetype();                      \
+    assert(archetype);                                                    \
+    return fn(archetype, I);                                              \
   }
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialAddrInst)
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialRefInst)
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialBoxInst)
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialBoxValueInst)
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialMetatypeInst)
+  SINGLE_VALUE_SINGLE_OPEN(OpenExistentialValueInst)
+#undef SINGLE_VALUE_SINGLE_OPEN
   default:
-    return CanOpenedArchetypeType();
+    return;
   }
 }
 
diff --git a/lib/SIL/IR/SILModule.cpp b/lib/SIL/IR/SILModule.cpp
@@ -260,17 +260,15 @@ void *SILModule::allocateInst(unsigned Size, unsigned Align) const {
 
 void SILModule::willDeleteInstruction(SILInstruction *I) {
   // Update RootOpenedArchetypeDefs.
-  if (auto *svi = dyn_cast<SingleValueInstruction>(I)) {
-    if (const CanOpenedArchetypeType archeTy =
-            svi->getDefinedOpenedArchetype()) {
-      OpenedArchetypeKey key = {archeTy, svi->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.
-      if (RootOpenedArchetypeDefs.lookup(key) == svi)
-        RootOpenedArchetypeDefs.erase(key);
-    }
-  }
+  I->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
+                                       SILValue dependency) {
+    OpenedArchetypeKey key = {archeTy, 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.
+    if (RootOpenedArchetypeDefs.lookup(key) == dependency)
+      RootOpenedArchetypeDefs.erase(key);
+  });
 }
 
 void SILModule::scheduleForDeletion(SILInstruction *I) {
@@ -766,45 +764,41 @@ unsigned SILModule::getCaseIndex(EnumElementDecl *enumElement) {
 }
 
 void SILModule::notifyAddedInstruction(SILInstruction *inst) {
-  if (auto *svi = dyn_cast<SingleValueInstruction>(inst)) {
-    if (const CanOpenedArchetypeType archeTy =
-            svi->getDefinedOpenedArchetype()) {
-      SILValue &val = RootOpenedArchetypeDefs[{archeTy, 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 opened archetype in function "
-                       << svi->getFunction()->getName() << ":\n";
-          svi->print(llvm::errs());
-          llvm::errs() << "previously defined in function "
-                       << val->getFunction()->getName() << ":\n";
-          val->print(llvm::errs());
-          abort();
-        }
-        // The opened archetype was unresolved so far. Replace the placeholder
-        // by inst.
-        auto *placeholder = cast<PlaceholderValue>(val);
-        placeholder->replaceAllUsesWith(svi);
-        ::delete placeholder;
-        numUnresolvedOpenedArchetypes--;
+  inst->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
+                                          SILValue dependency) {
+    SILValue &val = RootOpenedArchetypeDefs[{archeTy, 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 opened archetype 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();
       }
-      val = svi;
+      // The opened archetype was unresolved so far. Replace the placeholder
+      // by inst.
+      auto *placeholder = cast<PlaceholderValue>(val);
+      placeholder->replaceAllUsesWith(dependency);
+      ::delete placeholder;
+      numUnresolvedOpenedArchetypes--;
     }
-  }
+    val = dependency;
+  });
 }
 
 void SILModule::notifyMovedInstruction(SILInstruction *inst,
                                        SILFunction *fromFunction) {
-  if (auto *svi = dyn_cast<SingleValueInstruction>(inst)) {
-    if (const CanOpenedArchetypeType archeTy =
-            svi->getDefinedOpenedArchetype()) {
-      OpenedArchetypeKey key = {archeTy, fromFunction};
-      assert(RootOpenedArchetypeDefs.lookup(key) == svi &&
-             "archetype def was not registered");
-      RootOpenedArchetypeDefs.erase(key);
-      RootOpenedArchetypeDefs[{archeTy, svi->getFunction()}] = svi;
-    }
-  }
+  inst->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
+                                          SILValue dependency) {
+    OpenedArchetypeKey key = {archeTy, fromFunction};
+    assert(RootOpenedArchetypeDefs.lookup(key) == dependency &&
+           "archetype def was not registered");
+    RootOpenedArchetypeDefs.erase(key);
+    RootOpenedArchetypeDefs[{archeTy, inst->getFunction()}] = dependency;
+  });
 }
 
 // TODO: We should have an "isNoReturn" bit on Swift's BuiltinInfo, but for
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -1645,13 +1645,20 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
         require((ValueBase *)V == AI->getFunction()->getDynamicSelfMetadata(),
                 "wrong self metadata operand");
       } else {
-        require(isa<SingleValueInstruction>(V),
+        auto DI = V->getDefiningInstruction();
+        require(DI,
                 "opened archetype operand should refer to a SIL instruction");
-        auto Archetype =
-            cast<SingleValueInstruction>(V)->getDefinedOpenedArchetype();
-        require(Archetype,
+        bool definesFoundArchetype = false;
+        bool definesAnyArchetype = false;
+        DI->forEachDefinedOpenedArchetype(
+            [&](CanOpenedArchetypeType archetype, SILValue dependency) {
+          definesAnyArchetype = true;
+          if (FoundRootOpenedArchetypes.count(archetype))
+            definesFoundArchetype = true;
+        });
+        require(definesAnyArchetype,
                 "opened archetype operand should define an opened archetype");
-        require(FoundRootOpenedArchetypes.count(Archetype),
+        require(definesFoundArchetype,
                 "opened archetype operand does not correspond to any opened "
                 "archetype from the substitutions list");
       }
diff --git a/lib/SILOptimizer/Mandatory/AddressLowering.cpp b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
@@ -1301,8 +1301,8 @@ AllocStackInst *OpaqueStorageAllocation::createStackAllocation(SILValue value) {
   // Instructions that produce an opened type never reach here because they
   // have guaranteed ownership--they project their storage. We reach this
   // point after the opened value has been copied.
-  assert((!isa<SingleValueInstruction>(value)
-          || !cast<SingleValueInstruction>(value)->getDefinedOpenedArchetype())
+  assert((!value->getDefiningInstruction() ||
+          !value->getDefiningInstruction()->definesOpenedArchetypes())
          && "owned open_existential is unsupported");
 
   SILType allocTy = value->getType();
diff --git a/lib/SILOptimizer/Transforms/CSE.cpp b/lib/SILOptimizer/Transforms/CSE.cpp
@@ -665,7 +665,8 @@ class CSE {
   };
 
   bool processNode(DominanceInfoNode *Node);
-  bool processOpenExistentialRef(OpenExistentialRefInst *Inst, ValueBase *V);
+  bool processOpenExistentialRef(OpenExistentialRefInst *Inst,
+                                 OpenExistentialRefInst *V);
 };
 } // namespace swift
 
@@ -802,11 +803,7 @@ static void updateBasicBlockArgTypes(SILBasicBlock *BB,
 /// \Inst is the open_existential_ref instruction
 /// \V is the dominating open_existential_ref instruction
 bool CSE::processOpenExistentialRef(OpenExistentialRefInst *Inst,
-                                    ValueBase *V) {
-  // All the open instructions are single-value instructions.
-  auto VI = dyn_cast<SingleValueInstruction>(V);
-  if (!VI) return false;
-
+                                    OpenExistentialRefInst *VI) {
   llvm::SmallSetVector<SILInstruction *, 16> Candidates;
   const auto OldOpenedArchetype = Inst->getDefinedOpenedArchetype();
   const auto NewOpenedArchetype = VI->getDefinedOpenedArchetype();
