Merge pull request #73775 from slavapestov/more-sil-cloner-cleanup

More SILCloner cleanups

Author: slavapestov

include/swift/SIL/SILBasicBlock.h

@@ -174,6 +174,9 @@ public SwiftObjectHeader {
   /// This method unlinks 'self' from the containing SILFunction and deletes it.
   void eraseFromParent();
 
+  /// Replaces usages of this block with 'undef's and then deletes it.
+  void removeDeadBlock();
+
   /// Remove all instructions of a SILGlobalVariable's static initializer block.
   void clearStaticInitializerBlock(SILModule &module);
 

include/swift/SIL/SILCloner.h

@@ -449,29 +449,90 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   SILLocation remapLocation(SILLocation Loc) { return Loc; }
   const SILDebugScope *remapScope(const SILDebugScope *DS) { return DS; }
 
+  bool shouldSubstOpaqueArchetypes() const { return false; }
+
   SILType remapType(SILType Ty) {
     if (Functor.SubsMap || Ty.hasLocalArchetype()) {
       Ty = Ty.subst(Builder.getModule(), Functor, Functor,
                     CanGenericSignature());
     }
 
+    if (asImpl().shouldSubstOpaqueArchetypes()) {
+      auto context = getBuilder().getTypeExpansionContext();
+
+      if (!Ty.hasOpaqueArchetype() ||
+          !context.shouldLookThroughOpaqueTypeArchetypes())
+        return Ty;
+
+      // Remap types containing opaque result types in the current context.
+      Ty = getBuilder().getTypeLowering(Ty).getLoweredType().getCategoryType(
+          Ty.getCategory());
+    }
+
     return Ty;
   }
 
   CanType remapASTType(CanType ty) {
     if (Functor.SubsMap || ty->hasLocalArchetype())
       ty = ty.subst(Functor, Functor)->getCanonicalType();
 
+    if (asImpl().shouldSubstOpaqueArchetypes()) {
+      auto context = getBuilder().getTypeExpansionContext();
+
+      if (!ty->hasOpaqueArchetype() ||
+          !context.shouldLookThroughOpaqueTypeArchetypes())
+        return ty;
+
+      // Remap types containing opaque result types in the current context.
+      return substOpaqueTypesWithUnderlyingTypes(ty, context,
+                                                 /*allowLoweredTypes=*/false);
+    }
+
     return ty;
   }
 
   ProtocolConformanceRef remapConformance(Type Ty, ProtocolConformanceRef C) {
-    if (Functor.SubsMap || Ty->hasLocalArchetype())
+    if (Functor.SubsMap || Ty->hasLocalArchetype()) {
       C = C.subst(Ty, Functor, Functor);
+      if (asImpl().shouldSubstOpaqueArchetypes())
+        Ty = Ty.subst(Functor, Functor);
+    }
+
+    if (asImpl().shouldSubstOpaqueArchetypes()) {
+      auto context = getBuilder().getTypeExpansionContext();
+
+      if (!Ty->hasOpaqueArchetype() ||
+          !context.shouldLookThroughOpaqueTypeArchetypes())
+        return C;
+
+      return substOpaqueTypesWithUnderlyingTypes(C, Ty, context);
+    }
 
     return C;
   }
 
+  SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {
+    // If we have local archetypes to substitute, do so now.
+    if (Subs.hasLocalArchetypes() || Functor.SubsMap)
+      Subs = Subs.subst(Functor, Functor);
+
+    if (asImpl().shouldSubstOpaqueArchetypes()) {
+      auto context = getBuilder().getTypeExpansionContext();
+
+      if (!Subs.hasOpaqueArchetypes() ||
+          !context.shouldLookThroughOpaqueTypeArchetypes())
+        return Subs;
+
+      ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+        context.getContext(), context.getResilienceExpansion(),
+        context.isWholeModuleContext());
+      return Subs.subst(replacer, replacer,
+                        SubstFlags::SubstituteOpaqueArchetypes);
+    }
+
+    return Subs;
+  }
+
   /// Get the value that takes the place of the given `Value` within the cloned
   /// region. The given value must already have been mapped by this cloner.
   SILValue getMappedValue(SILValue Value);
@@ -481,14 +542,6 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   SILBasicBlock *remapBasicBlock(SILBasicBlock *BB);
   void postProcess(SILInstruction *Orig, SILInstruction *Cloned);
 
-  SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {
-    // If we have local archetypes to substitute, do so now.
-    if (Subs.hasLocalArchetypes() || Functor.SubsMap)
-      Subs = Subs.subst(Functor, Functor);
-
-    return Subs;
-  }
-
   /// This is called by either of the top-level visitors, cloneReachableBlocks
   /// or cloneSILFunction, after all other visitors are have been called.
 

include/swift/SIL/TypeSubstCloner.h

@@ -175,70 +175,15 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
   }
 
 protected:
+  bool shouldSubstOpaqueArchetypes() const { return true; }
+
   SILType remapType(SILType Ty) {
     SILType &Sty = TypeCache[Ty];
-    if (!Sty) {
-      Sty = Ty;
-
-      Sty = Sty.subst(getBuilder().getModule(), Functor, Functor);
-
-      auto context = getBuilder().getTypeExpansionContext();
-
-      if (!Sty.hasOpaqueArchetype() ||
-          !context.shouldLookThroughOpaqueTypeArchetypes())
-        return Sty;
-
-      // Remap types containing opaque result types in the current context.
-      Sty = getBuilder().getTypeLowering(Sty).getLoweredType().getCategoryType(
-          Sty.getCategory());
-    }
+    if (!Sty)
+      Sty = SILClonerWithScopes<ImplClass>::remapType(Ty);
     return Sty;
   }
 
-  CanType remapASTType(CanType ty) {
-    auto substTy = ty.subst(Functor, Functor)->getCanonicalType();
-
-    auto context = getBuilder().getTypeExpansionContext();
-
-    if (!substTy->hasOpaqueArchetype() ||
-        !context.shouldLookThroughOpaqueTypeArchetypes())
-      return substTy;
-
-    // Remap types containing opaque result types in the current context.
-    return substOpaqueTypesWithUnderlyingTypes(substTy, context,
-                                               /*allowLoweredTypes=*/false);
-  }
-
-  ProtocolConformanceRef remapConformance(Type ty,
-                                          ProtocolConformanceRef conf) {
-    auto substTy = ty.subst(Functor, Functor)->getCanonicalType();
-    auto substConf = conf.subst(ty, Functor, Functor);
-
-    auto context = getBuilder().getTypeExpansionContext();
-
-    if (!substTy->hasOpaqueArchetype() ||
-        !context.shouldLookThroughOpaqueTypeArchetypes())
-      return substConf;
-
-    return substOpaqueTypesWithUnderlyingTypes(substConf, substTy, context);
-  }
-
-  SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {
-    Subs = Subs.subst(Functor, Functor);
-
-    auto context = getBuilder().getTypeExpansionContext();
-
-    if (!Subs.hasOpaqueArchetypes() ||
-        !context.shouldLookThroughOpaqueTypeArchetypes())
-      return Subs;
-
-    ReplaceOpaqueTypesWithUnderlyingTypes replacer(
-      context.getContext(), context.getResilienceExpansion(),
-      context.isWholeModuleContext());
-    return Subs.subst(replacer, replacer,
-                      SubstFlags::SubstituteOpaqueArchetypes);
-  }
-
   void visitApplyInst(ApplyInst *Inst) {
     ApplySiteCloningHelper Helper(ApplySite(Inst), *this);
     ApplyInst *N =

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -83,13 +83,6 @@ class NonErrorHandlingBlocks {
   }
 };
 
-/// Remove all instructions in the body of \p bb in safe manner by using
-/// undef.
-void clearBlockBody(SILBasicBlock *bb);
-
-/// Handle the mechanical aspects of removing an unreachable block.
-void removeDeadBlock(SILBasicBlock *bb);
-
 /// Remove all unreachable blocks in a function.
 bool removeUnreachableBlocks(SILFunction &f);
 

lib/SIL/IR/SILBasicBlock.cpp

@@ -127,6 +127,29 @@ void SILBasicBlock::eraseFromParent() {
   getParent()->eraseBlock(this);
 }
 
+/// Handle the mechanical aspects of removing an unreachable block.
+void SILBasicBlock::removeDeadBlock() {
+  for (SILArgument *arg : getArguments()) {
+    arg->replaceAllUsesWithUndef();
+    // To appease the ownership verifier, just set to None.
+    arg->setOwnershipKind(OwnershipKind::None);
+  }
+
+  // Instructions in the dead block may be used by other dead blocks.  Replace
+  // any uses of them with undef values.
+  while (!empty()) {
+    // Grab the last instruction in the bb.
+    auto *inst = &back();
+
+    // Replace any still-remaining uses with undef values and erase.
+    inst->replaceAllUsesOfAllResultsWithUndef();
+    inst->eraseFromParent();
+  }
+
+  // Now that the bb is empty, eliminate it.
+  eraseFromParent();
+}
+
 void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
   assert(Other->isEntry() == isEntry() &&
          "Expected to both blocks to be entries or not");

lib/SILGen/SILGenLocalArchetype.cpp

@@ -110,29 +110,9 @@ class LocalArchetypeTransform : public SILCloner<LocalArchetypeTransform> {
     // Insert the new entry block at the beginning.
     F.moveBlockBefore(clonedEntryBlock, F.begin());
 
-    // FIXME: This should be a common utility.
-
     // Erase the old basic blocks.
     for (auto *bb : bbs) {
-      for (SILArgument *arg : bb->getArguments()) {
-        arg->replaceAllUsesWithUndef();
-        // To appease the ownership verifier, just set to None.
-        arg->setOwnershipKind(OwnershipKind::None);
-      }
-
-      // Instructions in the dead block may be used by other dead blocks. Replace
-      // any uses of them with undef values.
-      while (!bb->empty()) {
-        // Grab the last instruction in the bb.
-        auto *inst = &bb->back();
-
-        // Replace any still-remaining uses with undef values and erase.
-        inst->replaceAllUsesOfAllResultsWithUndef();
-        inst->eraseFromParent();
-      }
-
-      // Finally, erase the basic block itself.
-      bb->eraseFromParent();
+      bb->removeDeadBlock();
     }
   }
 };

lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp

@@ -380,7 +380,7 @@ void ExistentialTransform::populateThunkBody() {
   /// Remove original body of F.
   for (auto It = F->begin(), End = F->end(); It != End;) {
     auto *BB = &*It++;
-    removeDeadBlock(BB);
+    BB->removeDeadBlock();
   }
 
   /// Create a basic block and the function arguments.

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -642,7 +642,7 @@ bool SimplifyCFG::removeIfDead(SILBasicBlock *BB) {
     addToWorklist(S);
 
   LLVM_DEBUG(llvm::dbgs() << "remove dead bb" << BB->getDebugID() << '\n');
-  removeDeadBlock(BB);
+  BB->removeDeadBlock();
   ++NumBlocksDeleted;
   return true;
 }
@@ -1782,7 +1782,7 @@ bool SimplifyCFG::simplifySwitchEnumUnreachableBlocks(SwitchEnumInst *SEI) {
     addToWorklist(SEI->getParent());
     SILBuilderWithScope(SEI).createUnreachable(SEI->getLoc());
     for (auto &succ : SEI->getSuccessors()) {
-      removeDeadBlock(succ.getBB());
+      succ.getBB()->removeDeadBlock();
     }
     SEI->eraseFromParent();
     return true;

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -40,56 +40,7 @@ class MapOpaqueArchetypes : public SILCloner<MapOpaqueArchetypes> {
     clonedEntryBlock = fun.createBasicBlock();
   }
 
-  SILType remapType(SILType Ty) {
-    // Substitute local archetypes, if we have any.
-    if (Ty.hasLocalArchetype()) {
-      Ty = Ty.subst(getBuilder().getModule(), Functor, Functor,
-                    CanGenericSignature());
-    }
-
-    if (!Ty.hasOpaqueArchetype() ||
-        !getBuilder()
-             .getTypeExpansionContext()
-             .shouldLookThroughOpaqueTypeArchetypes())
-      return Ty;
-
-    return getBuilder().getTypeLowering(Ty).getLoweredType().getCategoryType(
-        Ty.getCategory());
-  }
-
-  CanType remapASTType(CanType ty) {
-    // Substitute local archetypes, if we have any.
-    if (ty->hasLocalArchetype())
-      ty = ty.subst(Functor, Functor)->getCanonicalType();
-
-    if (!ty->hasOpaqueArchetype() ||
-        !getBuilder()
-             .getTypeExpansionContext()
-             .shouldLookThroughOpaqueTypeArchetypes())
-      return ty;
-
-    return substOpaqueTypesWithUnderlyingTypes(
-        ty,
-        TypeExpansionContext(getBuilder().getFunction()),
-        /*allowLoweredTypes=*/false);
-  }
-
-  ProtocolConformanceRef remapConformance(Type ty,
-                                          ProtocolConformanceRef conf) {
-    // If we have local archetypes to substitute, do so now.
-    if (ty->hasLocalArchetype()) {
-      conf = conf.subst(ty, Functor, Functor);
-      ty = ty.subst(Functor, Functor);
-    }
-
-    auto context = getBuilder().getTypeExpansionContext();
-    if (ty->hasOpaqueArchetype() &&
-        context.shouldLookThroughOpaqueTypeArchetypes()) {
-      conf =
-          substOpaqueTypesWithUnderlyingTypes(conf, ty, context);
-    }
-    return conf;
-  }
+  bool shouldSubstOpaqueArchetypes() const { return true; }
 
   void replace();
 };

lib/SILOptimizer/Utils/BasicBlockOptUtils.cpp

@@ -67,37 +67,6 @@ NonErrorHandlingBlocks::NonErrorHandlingBlocks(SILFunction *function)
   }
 }
 
-/// Remove all instructions in the body of \p bb in safe manner by using
-/// undef.
-void swift::clearBlockBody(SILBasicBlock *bb) {
-
-  for (SILArgument *arg : bb->getArguments()) {
-    arg->replaceAllUsesWithUndef();
-    // To appease the ownership verifier, just set to None.
-    arg->setOwnershipKind(OwnershipKind::None);
-  }
-
-  // Instructions in the dead block may be used by other dead blocks.  Replace
-  // any uses of them with undef values.
-  while (!bb->empty()) {
-    // Grab the last instruction in the bb.
-    auto *inst = &bb->back();
-
-    // Replace any still-remaining uses with undef values and erase.
-    inst->replaceAllUsesOfAllResultsWithUndef();
-    inst->eraseFromParent();
-  }
-}
-
-// Handle the mechanical aspects of removing an unreachable block.
-void swift::removeDeadBlock(SILBasicBlock *bb) {
-  // Clear the body of bb.
-  clearBlockBody(bb);
-
-  // Now that the bb is empty, eliminate it.
-  bb->eraseFromParent();
-}
-
 bool swift::removeUnreachableBlocks(SILFunction &f) {
   ReachableBlocks reachable(&f);
   // Visit all the blocks without doing any extra work.
@@ -109,7 +78,7 @@ bool swift::removeUnreachableBlocks(SILFunction &f) {
   for (auto ii = std::next(f.begin()), end = f.end(); ii != end;) {
     auto *bb = &*ii++;
     if (!reachable.isVisited(bb)) {
-      removeDeadBlock(bb);
+      bb->removeDeadBlock();
       changed = true;
     }
   }