[LegacyPM] Remove dumpLastUses. NFC.

[foad]

Summary

dumpLastUses never prints anything because it uses the information in
InversedLastUser, but it is called before InversedLastUser is populated
by initializeAllAnalysisInfo.

[foad]

Rebase.

[foad]

This is no longer needed for D92309.

llvm/include/llvm/IR/LegacyPassManagers.h

public:
   // Access toplevel manager
   PMTopLevelManager *getTopLevelManager() { return TPM; }
   void setTopLevelManager(PMTopLevelManager *T) { TPM = T; }
 
   unsigned getDepth() const { return Depth; }
   void setDepth(unsigned newDepth) { Depth = newDepth; }
 
   // Print routines used by debug-pass
-  void dumpLastUses(Pass *P, unsigned Offset) const;
   void dumpPassArguments() const;
   void dumpPassInfo(Pass *P, enum PassDebuggingString S1,
                     enum PassDebuggingString S2, StringRef Msg);
   void dumpRequiredSet(const Pass *P) const;
   void dumpPreservedSet(const Pass *P) const;
   void dumpUsedSet(const Pass *P) const;
 
   unsigned getNumContainedPasses() const {

llvm/lib/Analysis/CallGraphSCCPass.cpp

public:
   Pass *getAsPass() override { return this; }
 
   // Print passes managed by this manager
   void dumpPassStructure(unsigned Offset) override {
     errs().indent(Offset*2) << "Call Graph SCC Pass Manager\n";
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       Pass *P = getContainedPass(Index);
       P->dumpPassStructure(Offset + 1);
-      dumpLastUses(P, Offset+1);
     }
   }
 
   Pass *getContainedPass(unsigned N) {
     assert(N < PassVector.size() && "Pass number out of range!");
     return static_cast<Pass *>(PassVector[N]);
   }
 

llvm/lib/Analysis/LoopPass.cpp

 }
 
 /// Print passes managed by this manager
 void LPPassManager::dumpPassStructure(unsigned Offset) {
   errs().indent(Offset*2) << "Loop Pass Manager\n";
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     Pass *P = getContainedPass(Index);
     P->dumpPassStructure(Offset + 1);
-    dumpLastUses(P, Offset+1);
   }
 }
 
 
 //===----------------------------------------------------------------------===//
 // LoopPass
 
 Pass *LoopPass::createPrinterPass(raw_ostream &O,

llvm/lib/Analysis/RegionPass.cpp

 }
 
 /// Print passes managed by this manager
 void RGPassManager::dumpPassStructure(unsigned Offset) {
   errs().indent(Offset*2) << "Region Pass Manager\n";
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     Pass *P = getContainedPass(Index);
     P->dumpPassStructure(Offset + 1);
-    dumpLastUses(P, Offset+1);
   }
 }
 
 namespace {
 //===----------------------------------------------------------------------===//
 // PrintRegionPass
 class PrintRegionPass : public RegionPass {
 private:

llvm/lib/IR/LegacyPassManager.cpp

void dumpPassStructure(unsigned Offset) override {
     dbgs().indent(Offset*2) << "ModulePass Manager\n";
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       ModulePass *MP = getContainedPass(Index);
       MP->dumpPassStructure(Offset + 1);
       MapVector<Pass *, legacy::FunctionPassManagerImpl *>::const_iterator I =
           OnTheFlyManagers.find(MP);
       if (I != OnTheFlyManagers.end())
         I->second->dumpPassStructure(Offset + 2);
-      dumpLastUses(MP, Offset+1);
     }
   }
 
   ModulePass *getContainedPass(unsigned N) {
     assert(N < PassVector.size() && "Pass number out of range!");
     return static_cast<ModulePass *>(PassVector[N]);
   }
 
Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) {
 
   // Search Parents through TopLevelManager
   if (SearchParent)
     return TPM->findAnalysisPass(AID);
 
   return nullptr;
 }
 
-// Print list of passes that are last used by P.
-void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{
-
-  SmallVector<Pass *, 12> LUses;
-
-  // If this is a on the fly manager then it does not have TPM.
-  if (!TPM)
-    return;
-
-  TPM->collectLastUses(LUses, P);
-
-  for (Pass *P : LUses) {
-    dbgs() << "--" << std::string(Offset*2, ' ');
-    P->dumpPassStructure(0);
-  }
-}
-
 void PMDataManager::dumpPassArguments() const {
   for (Pass *P : PassVector) {
     if (PMDataManager *PMD = P->getAsPMDataManager())
       PMD->dumpPassArguments();
     else
       if (const PassInfo *PI =
             TPM->findAnalysisPassInfo(P->getPassID()))
         if (!PI->isAnalysisGroup())

 
 char FPPassManager::ID = 0;
 /// Print passes managed by this manager
 void FPPassManager::dumpPassStructure(unsigned Offset) {
   dbgs().indent(Offset*2) << "FunctionPass Manager\n";
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
     FP->dumpPassStructure(Offset + 1);
-    dumpLastUses(FP, Offset+1);
   }
 }
 
 /// Execute all of the passes scheduled for execution by invoking
 /// runOnFunction method.  Keep track of whether any of the passes modifies
 /// the function, and if so, return true.
 bool FPPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())