[LegacyPassManager] Delete BasicBlockPass/Manager.

[asbirlea]

Summary

Delete the BasicBlockPass and BasicBlockManager, all its dependencies and update documentation.
The BasicBlockManager was improperly tested and found to be potentially broken, and was deprecated as of rL373254.

In light of the switch to the new pass manager coming before the next release, this patch is a first cleanup of the LegacyPassManager.

[chandlerc]

Generally very happy with this. Would like Eric to check this as well to think about the C API and other things that we maybe should be doing while unbuilding this....

[mehdi_amini]

Wow I thought we already deleted BBPass a while ago, good cleanup!

[echristo]

The straight removal and updates definitely make sense as-is. As far as I can tell the C API doesn't have support for BBP and we're fine deleting it even if so.

Things that should happen:

• We should absolutely put this as part of the release notes for the next release.

I can't think of anything else we might be missing here. Might want to send a message to llvm-dev to let people know it's happened in the near term.

Thanks!

llvm/docs/OptBisect.rst

 Pass base class contains a helper function that abstracts the details in order
 to make this check uniform across all passes.  These helper functions are:
 
 .. code-block:: c++
 
   bool ModulePass::skipModule(Module &M);
   bool CallGraphSCCPass::skipSCC(CallGraphSCC &SCC);
   bool FunctionPass::skipFunction(const Function &F);
-  bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB);
   bool LoopPass::skipLoop(const Loop *L);
 
 A MachineFunctionPass should use FunctionPass::skipFunction() as such:
 
 .. code-block:: c++
 
   bool MyMachineFunctionPass::runOnMachineFunction(Function &MF) {
     if (skipFunction(*MF.getFunction())

llvm/docs/WritingAnLLVMPass.rst

 All LLVM passes are subclasses of the `Pass
 <http://llvm.org/doxygen/classllvm_1_1Pass.html>`_ class, which implement
 functionality by overriding virtual methods inherited from ``Pass``.  Depending
 on how your pass works, you should inherit from the :ref:`ModulePass
 <writing-an-llvm-pass-ModulePass>` , :ref:`CallGraphSCCPass
 <writing-an-llvm-pass-CallGraphSCCPass>`, :ref:`FunctionPass
 <writing-an-llvm-pass-FunctionPass>` , or :ref:`LoopPass
 <writing-an-llvm-pass-LoopPass>`, or :ref:`RegionPass
-<writing-an-llvm-pass-RegionPass>`, or :ref:`BasicBlockPass
-<writing-an-llvm-pass-BasicBlockPass>` classes, which gives the system more
+<writing-an-llvm-pass-RegionPass>` classes, which gives the system more
 information about what your pass does, and how it can be combined with other
 passes.  One of the main features of the LLVM Pass Framework is that it
 schedules passes to run in an efficient way based on the constraints that your
 pass meets (which are indicated by which class they derive from).
 
 We start by showing you how to construct a pass, everything from setting up the
 code, to compiling, loading, and executing it.  After the basics are down, more
 advanced features are discussed.

 
 The `CallGraphSCCPass
 <http://llvm.org/doxygen/classllvm_1_1CallGraphSCCPass.html>`_ is used by
 passes that need to traverse the program bottom-up on the call graph (callees
 before callers).  Deriving from ``CallGraphSCCPass`` provides some mechanics
 for building and traversing the ``CallGraph``, but also allows the system to
 optimize execution of ``CallGraphSCCPass``\ es.  If your pass meets the
 requirements outlined below, and doesn't meet the requirements of a
-:ref:`FunctionPass <writing-an-llvm-pass-FunctionPass>` or :ref:`BasicBlockPass
-<writing-an-llvm-pass-BasicBlockPass>`, you should derive from
+:ref:`FunctionPass <writing-an-llvm-pass-FunctionPass>`, you should derive from
 ``CallGraphSCCPass``.
 
 ``TODO``: explain briefly what SCC, Tarjan's algo, and B-U mean.
 
 To be explicit, CallGraphSCCPass subclasses are:
 
 #. ... *not allowed* to inspect or modify any ``Function``\ s other than those
    in the current SCC and the direct callers and direct callees of the SCC.
.. code-block:: c++
 
   virtual bool doFinalization();
 
 The ``doFinalization`` method is an infrequently used method that is called
 when the pass framework has finished calling :ref:`runOnRegion
 <writing-an-llvm-pass-runOnRegion>` for every region in the program being
 compiled.
 
-.. _writing-an-llvm-pass-BasicBlockPass:
-
-The ``BasicBlockPass`` class
-----------------------------
-
-``BasicBlockPass``\ es are just like :ref:`FunctionPass's
-<writing-an-llvm-pass-FunctionPass>` , except that they must limit their scope
-of inspection and modification to a single basic block at a time.  As such,
-they are **not** allowed to do any of the following:
-
-#. Modify or inspect any basic blocks outside of the current one.
-#. Maintain state across invocations of :ref:`runOnBasicBlock
-   <writing-an-llvm-pass-runOnBasicBlock>`.
-#. Modify the control flow graph (by altering terminator instructions)
-#. Any of the things forbidden for :ref:`FunctionPasses
-   <writing-an-llvm-pass-FunctionPass>`.
-
-``BasicBlockPass``\ es are useful for traditional local and "peephole"
-optimizations.  They may override the same :ref:`doInitialization(Module &)
-<writing-an-llvm-pass-doInitialization-mod>` and :ref:`doFinalization(Module &)
-<writing-an-llvm-pass-doFinalization-mod>` methods that :ref:`FunctionPass's
-<writing-an-llvm-pass-FunctionPass>` have, but also have the following virtual
-methods that may also be implemented:
-
-The ``doInitialization(Function &)`` method
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: c++
-
-  virtual bool doInitialization(Function &F);
-
-The ``doInitialization`` method is allowed to do most of the things that
-``BasicBlockPass``\ es are not allowed to do, but that ``FunctionPass``\ es
-can.  The ``doInitialization`` method is designed to do simple initialization
-that does not depend on the ``BasicBlock``\ s being processed.  The
-``doInitialization`` method call is not scheduled to overlap with any other
-pass executions (thus it should be very fast).
-
-.. _writing-an-llvm-pass-runOnBasicBlock:
-
-The ``runOnBasicBlock`` method
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: c++
-
-  virtual bool runOnBasicBlock(BasicBlock &BB) = 0;
-
-Override this function to do the work of the ``BasicBlockPass``.  This function
-is not allowed to inspect or modify basic blocks other than the parameter, and
-are not allowed to modify the CFG.  A ``true`` value must be returned if the
-basic block is modified.
-
-The ``doFinalization(Function &)`` method
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: c++
-
-    virtual bool doFinalization(Function &F);
-
-The ``doFinalization`` method is an infrequently used method that is called
-when the pass framework has finished calling :ref:`runOnBasicBlock
-<writing-an-llvm-pass-runOnBasicBlock>` for every ``BasicBlock`` in the program
-being compiled.  This can be used to perform per-function finalization.
 
 The ``MachineFunctionPass`` class
 ---------------------------------
 
 A ``MachineFunctionPass`` is a part of the LLVM code generator that executes on
 the machine-dependent representation of each LLVM function in the program.
 
 Code generator passes are registered and initialized specially by

 to invalidate all others.
 
 The ``AnalysisUsage`` class provides several methods which are useful in
 certain circumstances that are related to ``addPreserved``.  In particular, the
 ``setPreservesAll`` method can be called to indicate that the pass does not
 modify the LLVM program at all (which is true for analyses), and the
 ``setPreservesCFG`` method can be used by transformations that change
 instructions in the program but do not modify the CFG or terminator
-instructions (note that this property is implicitly set for
-:ref:`BasicBlockPass <writing-an-llvm-pass-BasicBlockPass>`\ es).
+instructions.
 
 ``addPreserved`` is particularly useful for transformations like
 ``BreakCriticalEdges``.  This pass knows how to update a small set of loop and
 dominator related analyses if they exist, so it can preserve them, despite the
 fact that it hacks on the CFG.
 
 Example implementations of ``getAnalysisUsage``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

llvm/include/llvm/IR/IRPrintingPasses.h

 #ifndef LLVM_IR_IRPRINTINGPASSES_H
 #define LLVM_IR_IRPRINTINGPASSES_H
 
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace llvm {
 class Pass;
-class BasicBlockPass;
 class Function;
 class FunctionPass;
 class Module;
 class ModulePass;
 class PreservedAnalyses;
 class raw_ostream;
 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
 
 /// Create and return a pass that writes the module to the specified
 /// \c raw_ostream.
 ModulePass *createPrintModulePass(raw_ostream &OS,
                                   const std::string &Banner = "",
                                   bool ShouldPreserveUseListOrder = false);
 
 /// Create and return a pass that prints functions to the specified
 /// \c raw_ostream as they are processed.
 FunctionPass *createPrintFunctionPass(raw_ostream &OS,
                                       const std::string &Banner = "");
 
-/// Create and return a pass that writes the BB to the specified
-/// \c raw_ostream.
-BasicBlockPass *createPrintBasicBlockPass(raw_ostream &OS,
-                                          const std::string &Banner = "");
-
 /// Print out a name of an LLVM value without any prefixes.
 ///
 /// The name is surrounded with ""'s and escaped if it has any special or
 /// non-printable characters in it.
 void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name);
 
 /// Return true if a pass is for IR printing.
 bool isIRPrintingPass(Pass *P);

llvm/include/llvm/IR/LegacyPassManager.h

public:
   bool run(Module &M);
 
 private:
   /// PassManagerImpl_New is the actual class. PassManager is just the
   /// wraper to publish simple pass manager interface
   PassManagerImpl *PM;
 };
 
-/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
+/// FunctionPassManager manages FunctionPasses.
 class FunctionPassManager : public PassManagerBase {
 public:
   /// FunctionPassManager ctor - This initializes the pass manager.  It needs,
   /// but does not take ownership of, the specified Module.
   explicit FunctionPassManager(Module *M);
   ~FunctionPassManager() override;
 
   void add(Pass *P) override;

llvm/include/llvm/IR/LegacyPassManagers.h

 //
 // [o] class PMDataManager;
 //
 // PMDataManager manages information, e.g. list of available analysis info,
 // used by a pass manager to manage execution order of passes. It also provides
 // a place to implement common pass manager APIs. All pass managers derive from
 // PMDataManager.
 //
-// [o] class BBPassManager : public FunctionPass, public PMDataManager;
-//
-// BBPassManager manages BasicBlockPasses.
-//
 // [o] class FunctionPassManager;
 //
 // This is a external interface used to manage FunctionPasses. This
 // interface relies on FunctionPassManagerImpl to do all the tasks.
 //
 // [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager,
 //                                     public PMTopLevelManager;
 //

 class Timer;
 class PMDataManager;
 
 // enums for debugging strings
 enum PassDebuggingString {
   EXECUTION_MSG, // "Executing Pass '" + PassName
   MODIFICATION_MSG, // "Made Modification '" + PassName
   FREEING_MSG, // " Freeing Pass '" + PassName
-  ON_BASICBLOCK_MSG, // "' on BasicBlock '" + InstructionName + "'...\n"
   ON_FUNCTION_MSG, // "' on Function '" + FunctionName + "'...\n"
   ON_MODULE_MSG, // "' on Module '" + ModuleName + "'...\n"
   ON_REGION_MSG, // "' on Region '" + Msg + "'...\n'"
   ON_LOOP_MSG, // "' on Loop '" + Msg + "'...\n'"
   ON_CG_MSG // "' on Call Graph Nodes '" + Msg + "'...\n'"
 };
 
 /// PassManagerPrettyStackEntry - This is used to print informative information

llvm/include/llvm/InitializePasses.h

 void initializePostInlineEntryExitInstrumenterPass(PassRegistry&);
 void initializePostMachineSchedulerPass(PassRegistry&);
 void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
 void initializePostRAHazardRecognizerPass(PassRegistry&);
 void initializePostRAMachineSinkingPass(PassRegistry&);
 void initializePostRASchedulerPass(PassRegistry&);
 void initializePreISelIntrinsicLoweringLegacyPassPass(PassRegistry&);
 void initializePredicateInfoPrinterLegacyPassPass(PassRegistry&);
-void initializePrintBasicBlockPassPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
 void initializePrintModulePassWrapperPass(PassRegistry&);
 void initializeProcessImplicitDefsPass(PassRegistry&);
 void initializeProfileSummaryInfoWrapperPassPass(PassRegistry&);
 void initializePromoteLegacyPassPass(PassRegistry&);
 void initializePruneEHPass(PassRegistry&);
 void initializeRABasicPass(PassRegistry&);
 void initializeRAGreedyPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createReversePostOrderFunctionAttrsPass();
       (void) llvm::createMergeFunctionsPass();
       (void) llvm::createMergeICmpsLegacyPass();
       (void) llvm::createExpandMemCmpPass();
       std::string buf;
       llvm::raw_string_ostream os(buf);
       (void) llvm::createPrintModulePass(os);
       (void) llvm::createPrintFunctionPass(os);
-      (void) llvm::createPrintBasicBlockPass(os);
       (void) llvm::createModuleDebugInfoPrinterPass();
       (void) llvm::createPartialInliningPass();
       (void) llvm::createLintPass();
       (void) llvm::createSinkingPass();
       (void) llvm::createLowerAtomicPass();
       (void) llvm::createCorrelatedValuePropagationPass();
       (void) llvm::createMemDepPrinter();
       (void) llvm::createLoopVectorizePass();

llvm/include/llvm/Pass.h

 /// Ordering of pass manager types is important here.
 enum PassManagerType {
   PMT_Unknown = 0,
   PMT_ModulePassManager = 1, ///< MPPassManager
   PMT_CallGraphPassManager,  ///< CGPassManager
   PMT_FunctionPassManager,   ///< FPPassManager
   PMT_LoopPassManager,       ///< LPPassManager
   PMT_RegionPassManager,     ///< RGPassManager
-  PMT_BasicBlockPassManager, ///< BBPassManager
   PMT_Last
 };
 
 // Different types of passes.
 enum PassKind {
-  PT_BasicBlock,
   PT_Region,
   PT_Loop,
   PT_Function,
   PT_CallGraphSCC,
   PT_Module,
   PT_PassManager
 };
 

 
 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.
-///
-class BasicBlockPass : public Pass {
-public:
-  explicit BasicBlockPass(char &pid) : Pass(PT_BasicBlock, pid) {}
-
-  /// createPrinterPass - Get a basic block printer pass.
-  Pass *createPrinterPass(raw_ostream &OS,
-                          const std::string &Banner) const override;
-
-  using llvm::Pass::doInitialization;
-  using llvm::Pass::doFinalization;
-
-  /// doInitialization - Virtual method overridden by BasicBlockPass subclasses
-  /// to do any necessary per-function initialization.
-  virtual bool doInitialization(Function &);
-
-  /// runOnBasicBlock - Virtual method overriden by subclasses to do the
-  /// per-basicblock processing of the pass.
-  virtual bool runOnBasicBlock(BasicBlock &BB) = 0;
-
-  /// doFinalization - Virtual method overriden by BasicBlockPass subclasses to
-  /// do any post processing needed after all passes have run.
-  virtual bool doFinalization(Function &);
-
-  void preparePassManager(PMStack &PMS) override;
-
-  void assignPassManager(PMStack &PMS, PassManagerType T) override;
-
-  ///  Return what kind of Pass Manager can manage this pass.
-  PassManagerType getPotentialPassManagerType() const override;
-
-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 skipBasicBlock(const BasicBlock &BB) const;
-};
-
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// This is the storage for the -time-passes option.
 extern bool TimePassesIsEnabled;
 
 } // end namespace llvm
 
 // Include support files that contain important APIs commonly used by Passes,
 // but that we want to separate out to make it easier to read the header files.
 #include "llvm/InitializePasses.h"
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
 #endif // LLVM_PASS_H

llvm/include/llvm/Transforms/Scalar.h

 
 #ifndef LLVM_TRANSFORMS_SCALAR_H
 #define LLVM_TRANSFORMS_SCALAR_H
 
 #include <functional>
 
 namespace llvm {
 
-class BasicBlockPass;
 class Function;
 class FunctionPass;
 class ModulePass;
 class Pass;
 class GetElementPtrInst;
 class PassInfo;
 class TargetLowering;
 class TargetMachine;

 //
 // SCCP - Sparse conditional constant propagation.
 //
 FunctionPass *createSCCPPass();
 
 //===----------------------------------------------------------------------===//
 //
 // DeadInstElimination - This pass quickly removes trivially dead instructions
-// without modifying the CFG of the function.  It is a BasicBlockPass, so it
-// runs efficiently when queued next to other BasicBlockPass's.
+// without modifying the CFG of the function.  It is a FunctionPass.
 //
 Pass *createDeadInstEliminationPass();
 
 //===----------------------------------------------------------------------===//
 //
 // DeadCodeElimination - This pass is more powerful than DeadInstElimination,
 // because it is worklist driven that can potentially revisit instructions when
 // their other instructions become dead, to eliminate chains of dead

llvm/include/llvm/Transforms/Vectorize.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_VECTORIZE_H
 #define LLVM_TRANSFORMS_VECTORIZE_H
 
 namespace llvm {
 class BasicBlock;
-class BasicBlockPass;
 class Pass;
 
 //===----------------------------------------------------------------------===//
 /// Vectorize configuration.
 struct VectorizeConfig {
   //===--------------------------------------------------------------------===//
   // Target architecture related parameters
 

llvm/lib/IR/Core.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "ir"
 
 void llvm::initializeCore(PassRegistry &Registry) {
   initializeDominatorTreeWrapperPassPass(Registry);
   initializePrintModulePassWrapperPass(Registry);
   initializePrintFunctionPassWrapperPass(Registry);
-  initializePrintBasicBlockPassPass(Registry);
   initializeSafepointIRVerifierPass(Registry);
   initializeVerifierLegacyPassPass(Registry);
 }
 
 void LLVMInitializeCore(LLVMPassRegistryRef R) {
   initializeCore(*unwrap(R));
 }
 

llvm/lib/IR/IRPrintingPasses.cpp

public:
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   StringRef getPassName() const override { return "Print Function IR"; }
 };
 
-class PrintBasicBlockPass : public BasicBlockPass {
-  raw_ostream &Out;
-  std::string Banner;
-
-public:
-  static char ID;
-  PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
-  PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
-      : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
-
-  bool runOnBasicBlock(BasicBlock &BB) override {
-    Out << Banner << BB;
-    return false;
-  }
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-
-  StringRef getPassName() const override { return "Print BasicBlock IR"; }
-};
-
 }
 
 char PrintModulePassWrapper::ID = 0;
 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
                 "Print module to stderr", false, true)
 char PrintFunctionPassWrapper::ID = 0;
 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
                 "Print function to stderr", false, true)
-char PrintBasicBlockPass::ID = 0;
-INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
-                true)
 
 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
                                         const std::string &Banner,
                                         bool ShouldPreserveUseListOrder) {
   return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
 }
 
 FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
                                             const std::string &Banner) {
   return new PrintFunctionPassWrapper(OS, Banner);
 }
 
-BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
-                                                const std::string &Banner) {
-  return new PrintBasicBlockPass(OS, Banner);
-}
-
 bool llvm::isIRPrintingPass(Pass *P) {
   const char *PID = (const char*)P->getPassID();
 
-  return (PID == &PrintModulePassWrapper::ID)
-      || (PID == &PrintFunctionPassWrapper::ID)
-      || (PID == &PrintBasicBlockPass::ID);
+  return (PID == &PrintModulePassWrapper::ID) ||
+         (PID == &PrintFunctionPassWrapper::ID);
 }

llvm/lib/IR/LegacyPassManager.cpp

void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
   else
     OS << "value";
 
   OS << " '";
   V->printAsOperand(OS, /*PrintType=*/false, M);
   OS << "'\n";
 }
 
-
-namespace {
-//===----------------------------------------------------------------------===//
-// BBPassManager
-//
-/// BBPassManager manages BasicBlockPass. It batches all the
-/// pass together and sequence them to process one basic block before
-/// processing next basic block.
-class BBPassManager : public PMDataManager, public FunctionPass {
-
-public:
-  static char ID;
-  explicit BBPassManager()
-    : PMDataManager(), FunctionPass(ID) {}
-
-  /// Execute all of the passes scheduled for execution.  Keep track of
-  /// whether any of the passes modifies the function, and if so, return true.
-  bool runOnFunction(Function &F) override;
-
-  /// Pass Manager itself does not invalidate any analysis info.
-  void getAnalysisUsage(AnalysisUsage &Info) const override {
-    Info.setPreservesAll();
-  }
-
-  bool doInitialization(Module &M) override;
-  bool doInitialization(Function &F);
-  bool doFinalization(Module &M) override;
-  bool doFinalization(Function &F);
-
-  PMDataManager *getAsPMDataManager() override { return this; }
-  Pass *getAsPass() override { return this; }
-
-  StringRef getPassName() const override { return "BasicBlock Pass Manager"; }
-
-  // Print passes managed by this manager
-  void dumpPassStructure(unsigned Offset) override {
-    dbgs().indent(Offset*2) << "BasicBlockPass Manager\n";
-    for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-      BasicBlockPass *BP = getContainedPass(Index);
-      BP->dumpPassStructure(Offset + 1);
-      dumpLastUses(BP, Offset+1);
-    }
-  }
-
-  BasicBlockPass *getContainedPass(unsigned N) {
-    assert(N < PassVector.size() && "Pass number out of range!");
-    BasicBlockPass *BP = static_cast<BasicBlockPass *>(PassVector[N]);
-    return BP;
-  }
-
-  PassManagerType getPassManagerType() const override {
-    return PMT_BasicBlockPassManager;
-  }
-};
-
-char BBPassManager::ID = 0;
-} // End anonymous namespace
-
 namespace llvm {
 namespace legacy {
 //===----------------------------------------------------------------------===//
 // FunctionPassManagerImpl
 //
 /// FunctionPassManagerImpl manages FPPassManagers
 class FunctionPassManagerImpl : public Pass,
                                 public PMDataManager,
case MODIFICATION_MSG:
     break;
   case FREEING_MSG:
     dbgs() << " Freeing Pass '" << P->getPassName();
     break;
   default:
     break;
   }
   switch (S2) {
-  case ON_BASICBLOCK_MSG:
-    dbgs() << "' on BasicBlock '" << Msg << "'...\n";
-    break;
   case ON_FUNCTION_MSG:
     dbgs() << "' on Function '" << Msg << "'...\n";
     break;
   case ON_MODULE_MSG:
     dbgs() << "' on Module '"  << Msg << "'...\n";
     break;
   case ON_REGION_MSG:
     dbgs() << "' on Region '"  << Msg << "'...\n";

 }
 
 Pass *AnalysisResolver::findImplPass(Pass *P, AnalysisID AnalysisPI,
                                      Function &F) {
   return PM.getOnTheFlyPass(P, AnalysisPI, F);
 }
 
 //===----------------------------------------------------------------------===//
-// BBPassManager implementation
-
-/// Execute all of the passes scheduled for execution by invoking
-/// runOnBasicBlock method.  Keep track of whether any of the passes modifies
-/// the function, and if so, return true.
-bool BBPassManager::runOnFunction(Function &F) {
-  if (F.isDeclaration())
-    return false;
-
-  bool Changed = doInitialization(F);
-  Module &M = *F.getParent();
-
-  unsigned InstrCount, BBSize = 0;
-  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
-  bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
-  if (EmitICRemark)
-    InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
-
-  for (BasicBlock &BB : F) {
-    // Collect the initial size of the basic block.
-    if (EmitICRemark)
-      BBSize = BB.size();
-    for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-      BasicBlockPass *BP = getContainedPass(Index);
-      bool LocalChanged = false;
-
-      dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, BB.getName());
-      dumpRequiredSet(BP);
-
-      initializeAnalysisImpl(BP);
-
-      {
-        // If the pass crashes, remember this.
-        PassManagerPrettyStackEntry X(BP, BB);
-        TimeRegion PassTimer(getPassTimer(BP));
-        LocalChanged |= BP->runOnBasicBlock(BB);
-        if (EmitICRemark) {
-          unsigned NewSize = BB.size();
-          // Update the size of the basic block, emit a remark, and update the
-          // size of the module.
-          if (NewSize != BBSize) {
-            int64_t Delta =
-                static_cast<int64_t>(NewSize) - static_cast<int64_t>(BBSize);
-            emitInstrCountChangedRemark(BP, M, Delta, InstrCount,
-                                        FunctionToInstrCount, &F);
-            InstrCount = static_cast<int64_t>(InstrCount) + Delta;
-            BBSize = NewSize;
-          }
-        }
-      }
-
-      Changed |= LocalChanged;
-      if (LocalChanged)
-        dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG,
-                     BB.getName());
-      dumpPreservedSet(BP);
-      dumpUsedSet(BP);
-
-      verifyPreservedAnalysis(BP);
-      removeNotPreservedAnalysis(BP);
-      recordAvailableAnalysis(BP);
-      removeDeadPasses(BP, BB.getName(), ON_BASICBLOCK_MSG);
-    }
-  }
-
-  return doFinalization(F) || Changed;
-}
-
-// Implement doInitialization and doFinalization
-bool BBPassManager::doInitialization(Module &M) {
-  bool Changed = false;
-
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
-    Changed |= getContainedPass(Index)->doInitialization(M);
-
-  return Changed;
-}
-
-bool BBPassManager::doFinalization(Module &M) {
-  bool Changed = false;
-
-  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
-    Changed |= getContainedPass(Index)->doFinalization(M);
-
-  return Changed;
-}
-
-bool BBPassManager::doInitialization(Function &F) {
-  bool Changed = false;
-
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-    BasicBlockPass *BP = getContainedPass(Index);
-    Changed |= BP->doInitialization(F);
-  }
-
-  return Changed;
-}
-
-bool BBPassManager::doFinalization(Function &F) {
-  bool Changed = false;
-
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-    BasicBlockPass *BP = getContainedPass(Index);
-    Changed |= BP->doFinalization(F);
-  }
-
-  return Changed;
-}
-
-
-//===----------------------------------------------------------------------===//
 // FunctionPassManager implementation
 
 /// Create new Function pass manager
 FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
   FPM = new FunctionPassManagerImpl();
   // FPM is the top level manager.
   FPM->setTopLevelManager(FPM);
 
if (PMS.top()->getPassManagerType() == PMT_FunctionPassManager) {
     // [4] Push new manager into PMS
     PMS.push(FPP);
   }
 
   // Assign FPP as the manager of this pass.
   FPP->add(this);
 }
 
-void BasicBlockPass::preparePassManager(PMStack &PMS) {
-  // Find BBPassManager
-  while (!PMS.empty() &&
-         PMS.top()->getPassManagerType() > PMT_BasicBlockPassManager)
-    PMS.pop();
-
-  // If this pass is destroying high level information that is used
-  // by other passes that are managed by BBPM then do not insert
-  // this pass in current BBPM. Use new BBPassManager.
-  if (PMS.top()->getPassManagerType() == PMT_BasicBlockPassManager &&
-      !PMS.top()->preserveHigherLevelAnalysis(this))
-    PMS.pop();
-}
-
-/// Find appropriate Basic Pass Manager or Call Graph Pass Manager
-/// in the PM Stack and add self into that manager.
-void BasicBlockPass::assignPassManager(PMStack &PMS,
-                                       PassManagerType PreferredType) {
-  while (!PMS.empty() &&
-         PMS.top()->getPassManagerType() > PMT_BasicBlockPassManager)
-    PMS.pop();
-
-  BBPassManager *BBP;
-
-  // Basic Pass Manager is a leaf pass manager. It does not handle
-  // any other pass manager.
-  if (!PMS.empty() &&
-      PMS.top()->getPassManagerType() == PMT_BasicBlockPassManager) {
-    BBP = (BBPassManager *)PMS.top();
-  } else {
-    // If leaf manager is not Basic Block Pass manager then create new
-    // basic Block Pass manager.
-    assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager");
-    PMDataManager *PMD = PMS.top();
-
-    // [1] Create new Basic Block Manager
-    BBP = new BBPassManager();
-    BBP->populateInheritedAnalysis(PMS);
-
-    // [2] Set up new manager's top level manager
-    // Basic Block Pass Manager does not live by itself
-    PMTopLevelManager *TPM = PMD->getTopLevelManager();
-    TPM->addIndirectPassManager(BBP);
-
-    // [3] Assign manager to manage this new manager. This may create
-    // and push new managers into PMS
-    BBP->assignPassManager(PMS, PreferredType);
-
-    // [4] Push new manager into PMS
-    PMS.push(BBP);
-  }
-
-  // Assign BBP as the manager of this pass.
-  BBP->add(this);
-}
-
 PassManagerBase::~PassManagerBase() {}

llvm/lib/IR/Pass.cpp

bool FunctionPass::skipFunction(const Function &F) const {
   if (F.hasOptNone()) {
     LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
                       << F.getName() << "\n");
     return true;
   }
   return false;
 }
 
-//===----------------------------------------------------------------------===//
-// BasicBlockPass Implementation
-//
-
-Pass *BasicBlockPass::createPrinterPass(raw_ostream &OS,
-                                        const std::string &Banner) const {
-  return createPrintBasicBlockPass(OS, Banner);
-}
-
-bool BasicBlockPass::doInitialization(Function &) {
-  // By default, don't do anything.
-  return false;
-}
-
-bool BasicBlockPass::doFinalization(Function &) {
-  // By default, don't do anything.
-  return false;
-}
-
-static std::string getDescription(const BasicBlock &BB) {
-  return "basic block (" + BB.getName().str() + ") in function (" +
-         BB.getParent()->getName().str() + ")";
-}
-
-bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const {
-  const Function *F = BB.getParent();
-  if (!F)
-    return false;
-  OptPassGate &Gate = F->getContext().getOptPassGate();
-  if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(BB)))
-    return true;
-  if (F->hasOptNone()) {
-    // Report this only once per function.
-    if (&BB == &F->getEntryBlock())
-      LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()
-                        << "' on function " << F->getName() << "\n");
-    return true;
-  }
-  return false;
-}
-
-PassManagerType BasicBlockPass::getPotentialPassManagerType() const {
-  return PMT_BasicBlockPassManager;
-}
-
 const PassInfo *Pass::lookupPassInfo(const void *TI) {
   return PassRegistry::getPassRegistry()->getPassInfo(TI);
 }
 
 const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
   return PassRegistry::getPassRegistry()->getPassInfo(Arg);
 }
 

llvm/tools/bugpoint-passes/TestPasses.cpp

 #include "llvm/IR/Type.h"
 #include "llvm/Pass.h"
 
 #include "llvm/IR/PatternMatch.h"
 using namespace llvm::PatternMatch;
 using namespace llvm;
 
 namespace {
-  /// CrashOnCalls - This pass is used to test bugpoint.  It intentionally
-  /// crashes on any call instructions.
-  class CrashOnCalls : public BasicBlockPass {
-  public:
-    static char ID; // Pass ID, replacement for typeid
-    CrashOnCalls() : BasicBlockPass(ID) {}
-  private:
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.setPreservesAll();
-    }
+class CrashOnCalls : public FunctionPass {
+  CrashOnCalls() : FunctionPass(ID) {}
+
 
-    bool runOnBasicBlock(BasicBlock &BB) override {
+  bool runOnFunction(Function &F) override {
+    for (auto &BB : F)
       for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
         if (isa<CallInst>(*I))
           abort();
 
-      return false;
-    }
-  };
 }
 
 char CrashOnCalls::ID = 0;
 static RegisterPass<CrashOnCalls>
   X("bugpoint-crashcalls",
     "BugPoint Test Pass - Intentionally crash on CallInsts");
 
 namespace {
-  /// DeleteCalls - This pass is used to test bugpoint.  It intentionally
-  /// deletes some call instructions, "misoptimizing" the program.
-  class DeleteCalls : public BasicBlockPass {
-  public:
-    static char ID; // Pass ID, replacement for typeid
-    DeleteCalls() : BasicBlockPass(ID) {}
-  private:
-    bool runOnBasicBlock(BasicBlock &BB) override {
+class DeleteCalls : public FunctionPass {
+  DeleteCalls() : FunctionPass(ID) {}
+
+  bool runOnFunction(Function &F) override {
+    for (auto &BB : F)
       for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
         if (CallInst *CI = dyn_cast<CallInst>(I)) {
           if (!CI->use_empty())
             CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
           CI->getParent()->getInstList().erase(CI);
           break;
         }
-      return false;
-    }
-  };
 }
 
 char DeleteCalls::ID = 0;
 static RegisterPass<DeleteCalls>
   Y("bugpoint-deletecalls",
     "BugPoint Test Pass - Intentionally 'misoptimize' CallInsts");
 
 namespace {

llvm/tools/opt/PassPrinters.h

 
 #ifndef LLVM_TOOLS_OPT_PASSPRINTERS_H
 #define LLVM_TOOLS_OPT_PASSPRINTERS_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-class BasicBlockPass;
 class CallGraphSCCPass;
 class FunctionPass;
 class ModulePass;
 class LoopPass;
 class PassInfo;
 class raw_ostream;
 class RegionPass;
 class Module;
 
 FunctionPass *createFunctionPassPrinter(const PassInfo *PI, raw_ostream &out,
                                         bool Quiet);
 
 CallGraphSCCPass *createCallGraphPassPrinter(const PassInfo *PI,
                                              raw_ostream &out, bool Quiet);
 
 ModulePass *createModulePassPrinter(const PassInfo *PI, raw_ostream &out,
                                     bool Quiet);
 
 LoopPass *createLoopPassPrinter(const PassInfo *PI, raw_ostream &out,
                                 bool Quiet);
 
 RegionPass *createRegionPassPrinter(const PassInfo *PI, raw_ostream &out,
                                     bool Quiet);
 
-BasicBlockPass *createBasicBlockPassPrinter(const PassInfo *PI,
-                                            raw_ostream &out, bool Quiet);
-
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OPT_PASSPRINTERS_H

llvm/tools/opt/PassPrinters.cpp

struct RegionPassPrinter : public RegionPass {
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(PassToPrint->getTypeInfo());
     AU.setPreservesAll();
   }
 };
 
 char RegionPassPrinter::ID = 0;
 
-struct BasicBlockPassPrinter : public BasicBlockPass {
-  const PassInfo *PassToPrint;
-  raw_ostream &Out;
-  static char ID;
-  std::string PassName;
-  bool QuietPass;
-
-  BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : BasicBlockPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
-    std::string PassToPrintName = PassToPrint->getPassName();
-    PassName = "BasicBlockPass Printer: " + PassToPrintName;
-  }
-
-  bool runOnBasicBlock(BasicBlock &BB) override {
-    if (!QuietPass)
-      Out << "Printing Analysis info for BasicBlock '" << BB.getName()
-          << "': Pass " << PassToPrint->getPassName() << ":\n";
-
-    // Get and print pass...
-    getAnalysisID<Pass>(PassToPrint->getTypeInfo())
-        .print(Out, BB.getParent()->getParent());
-    return false;
-  }
-
-  StringRef getPassName() const override { return PassName; }
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequiredID(PassToPrint->getTypeInfo());
-    AU.setPreservesAll();
-  }
-};
-
-char BasicBlockPassPrinter::ID = 0;
-
 } // end anonymous namespace
 
 FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
                                               raw_ostream &OS, bool Quiet) {
   return new FunctionPassPrinter(PI, OS, Quiet);
 }
 
 CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS,
   return new LoopPassPrinter(PI, OS, Quiet);
 }
 
 RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS,
                                           bool Quiet) {
   return new RegionPassPrinter(PI, OS, Quiet);
 }
 
-BasicBlockPass *llvm::createBasicBlockPassPrinter(const PassInfo *PI,
-                                                  raw_ostream &OS, bool Quiet) {
-  return new BasicBlockPassPrinter(PI, OS, Quiet);
-}

llvm/tools/opt/opt.cpp

if (!WrapWithDebugify) {
       return;
     }
 
     // Apply -debugify/-check-debugify before/after each pass and collect
     // debug info loss statistics.
     PassKind Kind = P->getPassKind();
     StringRef Name = P->getPassName();
 
-    // TODO: Implement Debugify for BasicBlockPass, LoopPass.
+    // TODO: Implement Debugify for LoopPass.
     switch (Kind) {
       case PT_Function:
         super::add(createDebugifyFunctionPass());
         super::add(P);
         super::add(createCheckDebugifyFunctionPass(true, Name, &DIStatsMap));
         break;
       case PT_Module:
         super::add(createDebugifyModulePass());
else
       errs() << argv[0] << ": cannot create pass: "
              << PassInf->getPassName() << "\n";
     if (P) {
       PassKind Kind = P->getPassKind();
       addPass(Passes, P);
 
       if (AnalyzeOnly) {
         switch (Kind) {
-        case PT_BasicBlock:
-          Passes.add(createBasicBlockPassPrinter(PassInf, Out->os(), Quiet));
-          break;
         case PT_Region:
           Passes.add(createRegionPassPrinter(PassInf, Out->os(), Quiet));
           break;
         case PT_Loop:
           Passes.add(createLoopPassPrinter(PassInf, Out->os(), Quiet));
           break;
         case PT_Function:
           Passes.add(createFunctionPassPrinter(PassInf, Out->os(), Quiet));

llvm/unittests/IR/LegacyPassManagerTest.cpp

 
 using namespace llvm;
 
 namespace llvm {
   void initializeModuleNDMPass(PassRegistry&);
   void initializeFPassPass(PassRegistry&);
   void initializeCGPassPass(PassRegistry&);
   void initializeLPassPass(PassRegistry&);
-  void initializeBPassPass(PassRegistry&);
 
   namespace {
     // ND = no deps
     // NM = no modifications
     struct ModuleNDNM: public ModulePass {
     public:
       static char run;
       static char ID;
public:
         fincount++;
         finalized = true;
         return false;
       }
     };
     int LPass::initcount=0;
     int LPass::fincount=0;
 
-    struct BPass : public PassTestBase<BasicBlockPass> {
-    private:
-      static int inited;
-      static int fin;
-    public:
-      static void finishedOK(int run, int N) {
-        PassTestBase<BasicBlockPass>::finishedOK(run);
-        EXPECT_EQ(inited, N);
-        EXPECT_EQ(fin, N);
-      }
-      BPass() {
-        inited = 0;
-        fin = 0;
-      }
-      bool doInitialization(Module &M) override {
-        EXPECT_FALSE(initialized);
-        initialized = true;
-        return false;
-      }
-      bool doInitialization(Function &F) override {
-        inited++;
-        return false;
-      }
-      bool runOnBasicBlock(BasicBlock &BB) override {
-        run();
-        return false;
-      }
-      bool doFinalization(Function &F) override {
-        fin++;
-        return false;
-      }
-      bool doFinalization(Module &M) override {
-        EXPECT_FALSE(finalized);
-        finalized = true;
-        EXPECT_EQ(0, allocated);
-        return false;
-      }
-    };
-    int BPass::inited=0;
-    int BPass::fin=0;
-
     struct OnTheFlyTest: public ModulePass {
     public:
       static char ID;
       OnTheFlyTest() : ModulePass(ID) {
         initializeFPassPass(*PassRegistry::getPassRegistry());
       }
       bool runOnModule(Module &M) override {
         for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) {
TEST(PassManager, Memory) {
         SCOPED_TRACE("Function pass");
         MemoryTestHelper<FPass>(4);// 4 functions
       }
 
       {
         SCOPED_TRACE("Loop pass");
         MemoryTestHelper<LPass>(2, 1); //2 loops, 1 function
       }
-      {
-        SCOPED_TRACE("Basic block pass");
-        MemoryTestHelper<BPass>(7, 4); //9 basic blocks
-      }
 
     }
 
     TEST(PassManager, MemoryOnTheFly) {
       LLVMContext Context;
       Module *M = makeLLVMModule(Context);
       {
         SCOPED_TRACE("Running OnTheFlyTest");

 INITIALIZE_PASS(ModuleNDM, "mndm", "mndm", false, false)
 INITIALIZE_PASS_BEGIN(CGPass, "cgp","cgp", false, false)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_END(CGPass, "cgp","cgp", false, false)
 INITIALIZE_PASS(FPass, "fp","fp", false, false)
 INITIALIZE_PASS_BEGIN(LPass, "lp","lp", false, false)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_END(LPass, "lp","lp", false, false)
-INITIALIZE_PASS(BPass, "bp","bp", false, false)