[NewPM][PassInstrumentation] Add AfterPassSkipped callback

[yrouban]

Summary

AfterPassSkipped callback is added to have BeforePass callback correspond to some After* callback:

• AfterPass - if the pass ran
• AfterPassInvalidated - if the pass ran but invalidated the IRUnit
• AfterPassSkipped - if the pass was skipped because some of the BeforePass callbacks returned false.

These complete Before-After braces are needed for maintaining pass-related data structures in instrumentation passes. For example, stack of CFGs before passes in D81558 that checks PreserveCFG: in BeforePass a CFG snapshot is created and pushed to the stack, then in AfterPass it is popped from the stack and compared with current CFG. Even if we do not need to compare CFG we need to push and pop it from the stack.

[ychen]

llvm/include/llvm/IR/PassInstrumentation.h

81

I would prefer BeforeSkippedPassFunc. To be compatible with D84772

[yrouban]

See D84772.

llvm/include/llvm/IR/PassInstrumentation.h

81

With D84772 landed, this patch is not needed for D81558.
If BeforeNonSkippedPassFuncs is called, then there will be one of After* called.
So, I would vote for D84772 only.

llvm/include/llvm/IR/PassInstrumentation.h

public:
   // Before/After callbacks accept IRUnits whenever appropriate, so they need
   // to take them as constant pointers, wrapped with llvm::Any.
   // For the case when IRUnit has been invalidated there is a different
   // callback to use - AfterPassInvalidated.
   // TODO: currently AfterPassInvalidated does not accept IRUnit, since passing
   // already invalidated IRUnit is unsafe. There are ways to handle invalidated IRUnits
   // in a safe way, and we might pursue that as soon as there is a useful instrumentation
   // that needs it.
+  // For every Before callback called there is either After, AfterInvalidated
+  // or AfterSkipped call with the same pass name and IRUnit if available.
   using BeforePassFunc = bool(StringRef, Any);
+  using AfterPassSkippedFunc = void(StringRef, Any);
   using AfterPassFunc = void(StringRef, Any, const PreservedAnalyses &);
   using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
   using BeforeAnalysisFunc = void(StringRef, Any);
   using AfterAnalysisFunc = void(StringRef, Any);
 
 public:
   PassInstrumentationCallbacks() {}
 
   /// Copying PassInstrumentationCallbacks is not intended.
   PassInstrumentationCallbacks(const PassInstrumentationCallbacks &) = delete;
   void operator=(const PassInstrumentationCallbacks &) = delete;
 
   template <typename CallableT> void registerBeforePassCallback(CallableT C) {
     BeforePassCallbacks.emplace_back(std::move(C));
   }
 
+  template <typename CallableT>
+  void registerAfterPassSkippedCallback(CallableT C) {
+    AfterPassSkippedCallbacks.emplace_back(std::move(C));
+  }
+
   template <typename CallableT> void registerAfterPassCallback(CallableT C) {
     AfterPassCallbacks.emplace_back(std::move(C));
   }
 
   template <typename CallableT>
   void registerAfterPassInvalidatedCallback(CallableT C) {
     AfterPassInvalidatedCallbacks.emplace_back(std::move(C));
   }
 
   template <typename CallableT>
   void registerBeforeAnalysisCallback(CallableT C) {
     BeforeAnalysisCallbacks.emplace_back(std::move(C));
   }
 
   template <typename CallableT>
   void registerAfterAnalysisCallback(CallableT C) {
     AfterAnalysisCallbacks.emplace_back(std::move(C));
   }
 
 private:
   friend class PassInstrumentation;
 
   SmallVector<llvm::unique_function<BeforePassFunc>, 4> BeforePassCallbacks;
+  SmallVector<llvm::unique_function<AfterPassSkippedFunc>, 4>
+      AfterPassSkippedCallbacks;
   SmallVector<llvm::unique_function<AfterPassFunc>, 4> AfterPassCallbacks;
   SmallVector<llvm::unique_function<AfterPassInvalidatedFunc>, 4>
       AfterPassInvalidatedCallbacks;
   SmallVector<llvm::unique_function<BeforeAnalysisFunc>, 4>
       BeforeAnalysisCallbacks;
   SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>
       AfterAnalysisCallbacks;
 };
public:
   bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
     if (!Callbacks)
       return true;
 
     bool ShouldRun = true;
     for (auto &C : Callbacks->BeforePassCallbacks)
       ShouldRun &= C(Pass.name(), llvm::Any(&IR));
     ShouldRun = ShouldRun || isRequired(Pass);
+
+    if (!ShouldRun)
+      for (auto &C : Callbacks->AfterPassSkippedCallbacks)
+        C(Pass.name(), llvm::Any(&IR));
+
     return ShouldRun;
   }
 
   /// AfterPass instrumentation point - takes \p Pass instance that has
   /// just been executed and constant reference to \p IR it operates on.
   /// \p IR is guaranteed to be valid at this point.
   template <typename IRUnitT, typename PassT>
   void runAfterPass(const PassT &Pass, const IRUnitT &IR,