[NewPM][PassInstrument] Make PrintIR and TimePasses to use before-pass-run callback

[asbirlea]

lgtm

[aeubanks]

lgtm

[ychen]

• registerBeforePassRunCallback -> registerBeforeNonSkippedPassCallback

llvm/include/llvm/IR/PassTimingInfo.h

private:
 
   /// Returns the new timer for each new run of the pass.
   Timer &getPassTimer(StringRef PassID);
 
   void startTimer(StringRef PassID);
   void stopTimer(StringRef PassID);
 
   // Implementation of pass instrumentation callbacks.
-  bool runBeforePass(StringRef PassID);
+  void runBeforePass(StringRef PassID);
   void runAfterPass(StringRef PassID);
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Passes/StandardInstrumentations.h

 class PrintIRInstrumentation {
 public:
   PrintIRInstrumentation() = default;
   ~PrintIRInstrumentation();
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
-  bool printBeforePass(StringRef PassID, Any IR);
+  void printBeforePass(StringRef PassID, Any IR);
   void printAfterPass(StringRef PassID, Any IR);
   void printAfterPassInvalidated(StringRef PassID);
 
   using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;
 
   void pushModuleDesc(StringRef PassID, Any IR);
   PrintModuleDesc popModuleDesc(StringRef PassID);
 

llvm/lib/IR/PassTimingInfo.cpp

static bool matchPassManager(StringRef PassID) {
   size_t prefix_pos = PassID.find('<');
   if (prefix_pos == StringRef::npos)
     return false;
   StringRef Prefix = PassID.substr(0, prefix_pos);
   return Prefix.endswith("PassManager") || Prefix.endswith("PassAdaptor") ||
          Prefix.endswith("AnalysisManagerProxy");
 }
 
-bool TimePassesHandler::runBeforePass(StringRef PassID) {
+void TimePassesHandler::runBeforePass(StringRef PassID) {
   if (matchPassManager(PassID))
-    return true;
+    return;
 
   startTimer(PassID);
 
   LLVM_DEBUG(dbgs() << "after runBeforePass(" << PassID << ")\n");
   LLVM_DEBUG(dump());
-
-  // we are not going to skip this pass, thus return true.
-  return true;
 }
 
 void TimePassesHandler::runAfterPass(StringRef PassID) {
   if (matchPassManager(PassID))
     return;
 
   stopTimer(PassID);
 
   LLVM_DEBUG(dbgs() << "after runAfterPass(" << PassID << ")\n");
   LLVM_DEBUG(dump());
 }
 
 void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (!Enabled)
     return;
 
-  PIC.registerBeforePassCallback(
-      [this](StringRef P, Any) { return this->runBeforePass(P); });
+  PIC.registerBeforeNonSkippedPassCallback(
+      [this](StringRef P, Any) { this->runBeforePass(P); });
   PIC.registerAfterPassCallback(
       [this](StringRef P, Any) { this->runAfterPass(P); });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P) { this->runAfterPass(P); });
   PIC.registerBeforeAnalysisCallback(
       [this](StringRef P, Any) { this->runBeforePass(P); });
   PIC.registerAfterAnalysisCallback(
       [this](StringRef P, Any) { this->runAfterPass(P); });
 }
 
 } // namespace llvm

llvm/lib/Passes/StandardInstrumentations.cpp

 PrintIRInstrumentation::PrintModuleDesc
 PrintIRInstrumentation::popModuleDesc(StringRef PassID) {
   assert(!ModuleDescStack.empty() && "empty ModuleDescStack");
   PrintModuleDesc ModuleDesc = ModuleDescStack.pop_back_val();
   assert(std::get<2>(ModuleDesc).equals(PassID) && "malformed ModuleDescStack");
   return ModuleDesc;
 }
 
-bool PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
+void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
   if (PassID.startswith("PassManager<") || PassID.contains("PassAdaptor<"))
-    return true;
+    return;
 
   // Saving Module for AfterPassInvalidated operations.
   // Note: here we rely on a fact that we do not change modules while
   // traversing the pipeline, so the latest captured module is good
   // for all print operations that has not happen yet.
   if (StoreModuleDesc && llvm::shouldPrintAfterPass(PassID))
     pushModuleDesc(PassID, IR);
 
   if (!llvm::shouldPrintBeforePass(PassID))
-    return true;
+    return;
 
   SmallString<20> Banner = formatv("*** IR Dump Before {0} ***", PassID);
   unwrapAndPrint(IR, Banner, llvm::forcePrintModuleIR());
-  return true;
+  return;
 }
 
 void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
   if (PassID.startswith("PassManager<") || PassID.contains("PassAdaptor<"))
     return;
 
   if (!llvm::shouldPrintAfterPass(PassID))
     return;

 }
 
 void PrintIRInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   // BeforePass callback is not just for printing, it also saves a Module
   // for later use in AfterPassInvalidated.
   StoreModuleDesc = llvm::forcePrintModuleIR() && llvm::shouldPrintAfterPass();
   if (llvm::shouldPrintBeforePass() || StoreModuleDesc)
-    PIC.registerBeforePassCallback(
-        [this](StringRef P, Any IR) { return this->printBeforePass(P, IR); });
+    PIC.registerBeforeNonSkippedPassCallback(
+        [this](StringRef P, Any IR) { this->printBeforePass(P, IR); });
 
   if (llvm::shouldPrintAfterPass()) {
     PIC.registerAfterPassCallback(
         [this](StringRef P, Any IR) { this->printAfterPass(P, IR); });
     PIC.registerAfterPassInvalidatedCallback(
         [this](StringRef P) { this->printAfterPassInvalidated(P); });
   }
 }