[LegacyPassManager] Deprecate the BasicBlockPass/Manager.

[asbirlea]

Summary

The BasicBlockManager is potentially broken and should not be used.
Replace all uses of the BasicBlockPass with a FunctionBlockPass+loop on
blocks.

[tra]

LGTM.

include/llvm/Pass.h

309–311 ↗

(On Diff #222462)

Would it make sense to add an __attribute__((__deprected__...)) to relevant functions?

[asbirlea]

include/llvm/Pass.h

309–311 ↗

(On Diff #222462)

I tried to add the attribute to the class, but there are still the Printer passes which I can only remove, not update. So I resigned myself to only add a comment in this cleanup and have another one later to delete unnecessary code.

[tra]

include/llvm/Pass.h

309–311 ↗

(On Diff #222462)

SGTM.

llvm/trunk/include/llvm/Pass.h

 protected:
   /// Optional passes call this function to check whether the pass should be
   /// skipped. This is the case when Attribute::OptimizeNone is set or when
   /// optimization bisect is over the limit.
   bool skipFunction(const Function &F) const;
 };
 
 //===----------------------------------------------------------------------===//
+/// Deprecated - do not create new passes as BasicBlockPasses. Use FunctionPass
+/// with a loop over the BasicBlocks instead.
+//
 /// BasicBlockPass class - This class is used to implement most local
 /// optimizations.  Optimizations should subclass this class if they
 /// meet the following constraints:
 ///   1. Optimizations are local, operating on either a basic block or
 ///      instruction at a time.
 ///   2. Optimizations do not modify the CFG of the contained function, or any
 ///      other basic block in the function.
 ///   3. Optimizations conform to all of the constraints of FunctionPasses.

llvm/trunk/lib/Target/NVPTX/NVPTX.h

 ModulePass *createNVPTXAssignValidGlobalNamesPass();
 ModulePass *createGenericToNVVMPass();
 FunctionPass *createNVVMIntrRangePass(unsigned int SmVersion);
 FunctionPass *createNVVMReflectPass(unsigned int SmVersion);
 MachineFunctionPass *createNVPTXPrologEpilogPass();
 MachineFunctionPass *createNVPTXReplaceImageHandlesPass();
 FunctionPass *createNVPTXImageOptimizerPass();
 FunctionPass *createNVPTXLowerArgsPass(const NVPTXTargetMachine *TM);
-BasicBlockPass *createNVPTXLowerAllocaPass();
+FunctionPass *createNVPTXLowerAllocaPass();
 MachineFunctionPass *createNVPTXPeephole();
 MachineFunctionPass *createNVPTXProxyRegErasurePass();
 
 namespace NVPTX {
 enum DrvInterface {
   NVCL,
   CUDA
 };

llvm/trunk/lib/Target/NVPTX/NVPTXLowerAlloca.cpp

 
 using namespace llvm;
 
 namespace llvm {
 void initializeNVPTXLowerAllocaPass(PassRegistry &);
 }
 
 namespace {
-class NVPTXLowerAlloca : public BasicBlockPass {
-  bool runOnBasicBlock(BasicBlock &BB) override;
+class NVPTXLowerAlloca : public FunctionPass {
+  bool runOnFunction(Function &F) override;
 
 public:
   static char ID; // Pass identification, replacement for typeid
-  NVPTXLowerAlloca() : BasicBlockPass(ID) {}
+  NVPTXLowerAlloca() : FunctionPass(ID) {}
   StringRef getPassName() const override {
     return "convert address space of alloca'ed memory to local";
   }
 };
 } // namespace
 
 char NVPTXLowerAlloca::ID = 1;
 
 INITIALIZE_PASS(NVPTXLowerAlloca, "nvptx-lower-alloca",
                 "Lower Alloca", false, false)
 
 // =============================================================================
 // Main function for this pass.
 // =============================================================================
-bool NVPTXLowerAlloca::runOnBasicBlock(BasicBlock &BB) {
-  if (skipBasicBlock(BB))
+bool NVPTXLowerAlloca::runOnFunction(Function &F) {
+  if (skipFunction(F))
     return false;
 
   bool Changed = false;
+  for (auto &BB : F)
     for (auto &I : BB) {
       if (auto allocaInst = dyn_cast<AllocaInst>(&I)) {
         Changed = true;
         auto PTy = dyn_cast<PointerType>(allocaInst->getType());
         auto ETy = PTy->getElementType();
         auto LocalAddrTy = PointerType::get(ETy, ADDRESS_SPACE_LOCAL);
         auto NewASCToLocal = new AddrSpaceCastInst(allocaInst, LocalAddrTy, "");
         auto GenericAddrTy = PointerType::get(ETy, ADDRESS_SPACE_GENERIC);
-      auto NewASCToGeneric = new AddrSpaceCastInst(NewASCToLocal,
-                                                    GenericAddrTy, "");
+        auto NewASCToGeneric =
+            new AddrSpaceCastInst(NewASCToLocal, GenericAddrTy, "");
         NewASCToLocal->insertAfter(allocaInst);
         NewASCToGeneric->insertAfter(NewASCToLocal);
         for (Value::use_iterator UI = allocaInst->use_begin(),
                                  UE = allocaInst->use_end();
-            UI != UE; ) {
+             UI != UE;) {
           // Check Load, Store, GEP, and BitCast Uses on alloca and make them
           // use the converted generic address, in order to expose non-generic
           // addrspacecast to NVPTXInferAddressSpaces. For other types
           // of instructions this is unnecessary and may introduce redundant
           // address cast.
           const auto &AllocaUse = *UI++;
           auto LI = dyn_cast<LoadInst>(AllocaUse.getUser());
-        if (LI && LI->getPointerOperand() == allocaInst && !LI->isVolatile()) {
+          if (LI && LI->getPointerOperand() == allocaInst &&
+              !LI->isVolatile()) {
             LI->setOperand(LI->getPointerOperandIndex(), NewASCToGeneric);
             continue;
           }
           auto SI = dyn_cast<StoreInst>(AllocaUse.getUser());
-        if (SI && SI->getPointerOperand() == allocaInst && !SI->isVolatile()) {
+          if (SI && SI->getPointerOperand() == allocaInst &&
+              !SI->isVolatile()) {
             SI->setOperand(SI->getPointerOperandIndex(), NewASCToGeneric);
             continue;
           }
           auto GI = dyn_cast<GetElementPtrInst>(AllocaUse.getUser());
           if (GI && GI->getPointerOperand() == allocaInst) {
             GI->setOperand(GI->getPointerOperandIndex(), NewASCToGeneric);
             continue;
           }
           auto BI = dyn_cast<BitCastInst>(AllocaUse.getUser());
           if (BI && BI->getOperand(0) == allocaInst) {
             BI->setOperand(0, NewASCToGeneric);
             continue;
           }
         }
       }
     }
   return Changed;
 }
 
-BasicBlockPass *llvm::createNVPTXLowerAllocaPass() {
+FunctionPass *llvm::createNVPTXLowerAllocaPass() {
   return new NVPTXLowerAlloca();
 }

llvm/trunk/lib/Transforms/Scalar/DCE.cpp

 STATISTIC(DCEEliminated, "Number of insts removed");
 DEBUG_COUNTER(DCECounter, "dce-transform",
               "Controls which instructions are eliminated");
 
 namespace {
   //===--------------------------------------------------------------------===//
   // DeadInstElimination pass implementation
   //
-  struct DeadInstElimination : public BasicBlockPass {
-    static char ID; // Pass identification, replacement for typeid
-    DeadInstElimination() : BasicBlockPass(ID) {
-      initializeDeadInstEliminationPass(*PassRegistry::getPassRegistry());
-    }
-    bool runOnBasicBlock(BasicBlock &BB) override {
-      if (skipBasicBlock(BB))
-        return false;
-      auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
-      TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(*BB.getParent()) : nullptr;
-      bool Changed = false;
+struct DeadInstElimination : public FunctionPass {
+  DeadInstElimination() : FunctionPass(ID) {
+  bool runOnFunction(Function &F) override {
+    if (skipFunction(F))
+    TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(F) : nullptr;
+
+    for (auto &BB : F) {
       for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) {
         Instruction *Inst = &*DI++;
         if (isInstructionTriviallyDead(Inst, TLI)) {
           if (!DebugCounter::shouldExecute(DCECounter))
             continue;
           salvageDebugInfo(*Inst);
           Inst->eraseFromParent();
           Changed = true;
           ++DIEEliminated;
         }
       }
-      return Changed;
-    }
+    }
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesCFG();
     }
-  };
 }
 
 char DeadInstElimination::ID = 0;
 INITIALIZE_PASS(DeadInstElimination, "die",
                 "Dead Instruction Elimination", false, false)
 
 Pass *llvm::createDeadInstEliminationPass() {
   return new DeadInstElimination();