[NFC][Debugify] Rename OptCustomPassManager into DebugifyCustomPassManager

[djtodoro]

Summary

In addition, move the definition of the class into the Debugify.h, so we can use it from different levels.

The motivation for this is D82547.

[vsk]

llvm/include/llvm/IR/LegacyPassManager.h

100

The layering for this seems a bit strange, as LegacyPassManager doesn't have much to do with 'debugify'. How does moving the class into Debugify.h, and the class implementation into Debugify.cpp sound? That way, the new-PM version of this can live in the same files.

100

To be clear: I'm not asking that you implement a new-PM version of this, it's just some future-proofing.

[djtodoro]

llvm/include/llvm/IR/LegacyPassManager.h

100

Nice point, thanks!

I'd rather keep the class def in the Debugify.h in order to avoid linking additional stuff into the libLLVMTransformUtils (for example, isBitcodeWriterPass() won't be available while linking without CMake changes). WDYT?

[djtodoro]

• Move the def of DebugifyCustomPassManager into the Debugify.h

[vsk]

Lgtm.

[djtodoro]

@vsk Thanks!

llvm/include/llvm/IR/LegacyPassManager.h

 // destroyed when the PassManager is destroyed.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_LEGACYPASSMANAGER_H
 #define LLVM_IR_LEGACYPASSMANAGER_H
 
 #include "llvm/Pass.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
+#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Transforms/Utils/Debugify.h"
 
 namespace llvm {
 
 class Pass;
 class Module;
 
 namespace legacy {
 
public:
   ///
   bool doFinalization();
 
 private:
   FunctionPassManagerImpl *FPM;
   Module *M;
 };
 
+/// DebugifyCustomPassManager wraps each pass with the debugify passes if
+/// needed.
+class DebugifyCustomPassManager : public legacy::PassManager {
+  DebugifyStatsMap DIStatsMap;
+  bool EnableDebugifyEach = false;
+
+public:
+  using super = legacy::PassManager;
+
+  void add(Pass *P) override {
+    // Wrap each pass with (-check)-debugify passes if requested, making
+    // exceptions for passes which shouldn't see -debugify instrumentation.
+    bool WrapWithDebugify = EnableDebugifyEach && !P->getAsImmutablePass() &&
+                            !isIRPrintingPass(P) && !isBitcodeWriterPass(P);
+    if (!WrapWithDebugify) {
+      super::add(P);
+      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 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());
+      super::add(P);
+      super::add(createCheckDebugifyModulePass(true, Name, &DIStatsMap));
+      break;
+    default:
+      super::add(P);
+      break;
+    }
+  }
+
+  void enableDebugifyEach() { EnableDebugifyEach = true; }
+
+  const DebugifyStatsMap &getDebugifyStatsMap() const { return DIStatsMap; }
+};
+
 } // End legacy namespace
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_STDCXX_CONVERSION_FUNCTIONS(legacy::PassManagerBase, LLVMPassManagerRef)
 
 } // End llvm namespace
 
 #endif

llvm/lib/IR/LegacyPassManager.cpp

Pass *AnalysisResolver::findImplPass(Pass *P, AnalysisID AnalysisPI,
                                      Function &F) {
   return PM.getOnTheFlyPass(P, AnalysisPI, F);
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionPassManager implementation
 
 /// Create new Function pass manager
-FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
+llvm::legacy::FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
   FPM = new FunctionPassManagerImpl();
   // FPM is the top level manager.
   FPM->setTopLevelManager(FPM);
 
   AnalysisResolver *AR = new AnalysisResolver(*FPM);
   FPM->setResolver(AR);
 }
 
-FunctionPassManager::~FunctionPassManager() {
+llvm::legacy::FunctionPassManager::~FunctionPassManager() {
   delete FPM;
 }
 
-void FunctionPassManager::add(Pass *P) {
+void llvm::legacy::FunctionPassManager::add(Pass *P) {
   FPM->add(P);
 }
 
 /// run - 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 FunctionPassManager::run(Function &F) {
+bool llvm::legacy::FunctionPassManager::run(Function &F) {
   handleAllErrors(F.materialize(), [&](ErrorInfoBase &EIB) {
     report_fatal_error("Error reading bitcode file: " + EIB.message());
   });
   return FPM->run(F);
 }
 
 
 /// doInitialization - Run all of the initializers for the function passes.
 ///
-bool FunctionPassManager::doInitialization() {
+bool llvm::legacy::FunctionPassManager::doInitialization() {
   return FPM->doInitialization(*M);
 }
 
 /// doFinalization - Run all of the finalizers for the function passes.
 ///
-bool FunctionPassManager::doFinalization() {
+bool llvm::legacy::FunctionPassManager::doFinalization() {
   return FPM->doFinalization(*M);
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionPassManagerImpl implementation
 //
 bool FunctionPassManagerImpl::doInitialization(Module &M) {
   bool Changed = false;
bool PassManagerImpl::run(Module &M) {
 
   return Changed;
 }
 
 //===----------------------------------------------------------------------===//
 // PassManager implementation
 
 /// Create new pass manager
-PassManager::PassManager() {
+llvm::legacy::PassManager::PassManager() {
   PM = new PassManagerImpl();
   // PM is the top level manager
   PM->setTopLevelManager(PM);
 }
 
-PassManager::~PassManager() {
+llvm::legacy::PassManager::~PassManager() {
   delete PM;
 }
 
-void PassManager::add(Pass *P) {
+void llvm::legacy::PassManager::add(Pass *P) {
   PM->add(P);
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the module, and if so, return true.
-bool PassManager::run(Module &M) {
+bool llvm::legacy::PassManager::run(Module &M) {
   return PM->run(M);
 }
 
 //===----------------------------------------------------------------------===//
 // PMStack implementation
 //
 
 // Pop Pass Manager from the stack and clear its analysis info.

llvm/tools/opt/opt.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/RegionPass.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/AsmParser/Parser.h"
-#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
-#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"
cl::values(
         clEnumValN(
             CSInstrUse, "cspgo-instr-use-pipeline",
             "Use instrumented (context sensitive) profile to guide PGO.")));
 cl::opt<std::string> CSProfileGenFile(
     "cs-profilegen-file",
     cl::desc("Path to the instrumented context sensitive profile."),
     cl::Hidden);
 
-class OptCustomPassManager : public legacy::PassManager {
-  DebugifyStatsMap DIStatsMap;
-
-public:
-  using super = legacy::PassManager;
-
-  void add(Pass *P) override {
-    // Wrap each pass with (-check)-debugify passes if requested, making
-    // exceptions for passes which shouldn't see -debugify instrumentation.
-    bool WrapWithDebugify = DebugifyEach && !P->getAsImmutablePass() &&
-                            !isIRPrintingPass(P) && !isBitcodeWriterPass(P);
-    if (!WrapWithDebugify) {
-      super::add(P);
-      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 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());
-        super::add(P);
-        super::add(createCheckDebugifyModulePass(true, Name, &DIStatsMap));
-        break;
-      default:
-        super::add(P);
-        break;
-    }
-  }
-
-  const DebugifyStatsMap &getDebugifyStatsMap() const { return DIStatsMap; }
-};
-
 static inline void addPass(legacy::PassManagerBase &PM, Pass *P) {
   // Add the pass to the pass manager...
   PM.add(P);
 
   // If we are verifying all of the intermediate steps, add the verifier...
   if (VerifyEach)
     PM.add(createVerifierPass());
 }
return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
                            PreserveAssemblyUseListOrder,
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
                            EmitModuleHash, EnableDebugify, Coroutines)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
-  // about to build.
-  OptCustomPassManager Passes;
+  // about to build. If the -debugify-each option is set, wrap each pass with
+  // the (-check)-debugify passes.
+  llvm::legacy::DebugifyCustomPassManager Passes;
+  if (DebugifyEach)
+    Passes.enableDebugifyEach();
+
   bool AddOneTimeDebugifyPasses = EnableDebugify && !DebugifyEach;
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(ModuleTriple);
 
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();