[DebugCounter] Add support for non-continous ranges.

+ Script for bisecting though a build

Author: Ralender

llvm/docs/ProgrammersManual.rst

@@ -1362,16 +1362,14 @@ Whatever code you want that control, use ``DebugCounter::shouldExecute`` to cont
   if (DebugCounter::shouldExecute(DeleteAnInstruction))
     I->eraseFromParent();
 
-That's all you have to do.  Now, using opt, you can control when this code triggers using
-the '``--debug-counter``' option.  There are two counters provided, ``skip`` and ``count``.
-``skip`` is the number of times to skip execution of the codepath.  ``count`` is the number
-of times, once we are done skipping, to execute the codepath.
+That's all you have to do. Now, using opt, you can control when this code triggers using
+the '``--debug-counter``' Options.To specify when to execute the codepath.
 
 .. code-block:: none
 
-  $ opt --debug-counter=passname-delete-instruction-skip=1,passname-delete-instruction-count=2 -passname
+  $ opt --debug-counter=passname-delete-instruction=2-3 -passname
 
-This will skip the above code the first time we hit it, then execute it twice, then skip the rest of the executions.
+This will skip the above code the first two times we hit it, then execute it 2 times, then skip the rest of the executions.
 
 So if executed on the following code:
 
@@ -1384,9 +1382,28 @@ So if executed on the following code:
 
 It would delete number ``%2`` and ``%3``.
 
-A utility is provided in `utils/bisect-skip-count` to binary search
-skip and count arguments. It can be used to automatically minimize the
-skip and count for a debug-counter variable.
+A utility is provided in `llvm/tools/delta-driver/delta-driver.cpp` to drive the automated delta debugging.
+How to use delta-driver:
+First, Figure out the number of calls to the debug counter you want to minimize.
+To do so, run the compilation command causing issue with `-print-debug-counter` adding a `-mllvm` if needed.
+Than find the line with the counter of interest. it should look like:
+.. code-block:: none
+
+  my-counter               : {5678,empty}
+
+The number of calls to `my-counter` is 5678
+
+Than Find the minimum set of chunks that reproduce an issue, with `delta-driver`.
+Build a reproducer script like:
+.. code-block:: bash
+
+  #! /bin/bash
+  opt -debug-counter=my-counter=$1
+  # ... Test result of the command. Failure of the script is considered interesting
+
+Than run `delta-driver my-script.sh 0-5678 2>&1 | tee dump_bisect`
+This command may take some time.
+but when it is done, it will print the result like: `Minimal Chunks = 0:1:5:11-12:33-34`
 
 .. _ViewGraph:
 

llvm/include/llvm/IR/PassManager.h

@@ -64,6 +64,9 @@ extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
 
 namespace llvm {
 
+// Used for debug counter of adding a pass to the pipeline
+bool shouldAddNewPMPass();
+
 // Forward declare the analysis manager template.
 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
 
@@ -247,6 +250,8 @@ class PassManager : public PassInfoMixin<
 
   // FIXME: Revert to enable_if style when gcc >= 11.1
   template <typename PassT> LLVM_ATTRIBUTE_MINSIZE void addPass(PassT &&Pass) {
+    if (!shouldAddNewPMPass())
+      return;
     using PassModelT =
         detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
     if constexpr (!std::is_same_v<PassT, PassManager>) {

llvm/include/llvm/Support/DebugCounter.h

@@ -43,6 +43,7 @@
 #ifndef LLVM_SUPPORT_DEBUGCOUNTER_H
 #define LLVM_SUPPORT_DEBUGCOUNTER_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/UniqueVector.h"
@@ -53,6 +54,18 @@ namespace llvm {
 
 class raw_ostream;
 
+struct Chunk {
+  int64_t Begin;
+  int64_t End;
+  void print(llvm::raw_ostream &OS);
+  bool contains(int64_t Idx) { return Idx >= Begin && Idx <= End; }
+};
+
+void printChunks(raw_ostream &OS, ArrayRef<Chunk>);
+
+/// Return true on parsing error and print the error message on the llvm::errs()
+bool parseChunks(StringRef Str, SmallVector<Chunk> &Res);
+
 class DebugCounter {
 public:
   /// Returns a reference to the singleton instance.
@@ -77,18 +90,28 @@ class DebugCounter {
     auto Result = Us.Counters.find(CounterName);
     if (Result != Us.Counters.end()) {
       auto &CounterInfo = Result->second;
-      ++CounterInfo.Count;
+      int64_t CurrCount = CounterInfo.Count++;
+      uint64_t CurrIdx = CounterInfo.CurrChunkIdx;
 
-      // We only execute while the Skip is not smaller than Count,
-      // and the StopAfter + Skip is larger than Count.
-      // Negative counters always execute.
-      if (CounterInfo.Skip < 0)
+      if (CounterInfo.Chunks.empty())
         return true;
-      if (CounterInfo.Skip >= CounterInfo.Count)
+      if (CurrIdx >= CounterInfo.Chunks.size())
         return false;
-      if (CounterInfo.StopAfter < 0)
-        return true;
-      return CounterInfo.StopAfter + CounterInfo.Skip >= CounterInfo.Count;
+
+      bool Res = CounterInfo.Chunks[CurrIdx].contains(CurrCount);
+      if (Us.BreakOnLast && CurrIdx == (CounterInfo.Chunks.size() - 1) &&
+          CurrCount == CounterInfo.Chunks[CurrIdx].End) {
+        LLVM_BUILTIN_DEBUGTRAP;
+      }
+      if (CurrCount > CounterInfo.Chunks[CurrIdx].End) {
+        CounterInfo.CurrChunkIdx++;
+
+        /// Handle consecutive blocks.
+        if (CounterInfo.CurrChunkIdx < CounterInfo.Chunks.size() &&
+            CurrCount == CounterInfo.Chunks[CounterInfo.CurrChunkIdx].Begin)
+          return true;
+      }
+      return Res;
     }
     // Didn't find the counter, should we warn?
     return true;
@@ -152,11 +175,11 @@ class DebugCounter {
 #ifdef NDEBUG
     return false;
 #else
-    return instance().Enabled;
+    return instance().Enabled || instance().ShouldPrintCounter;
 #endif
   }
 
-private:
+protected:
   unsigned addCounter(const std::string &Name, const std::string &Desc) {
     unsigned Result = RegisteredCounters.insert(Name);
     Counters[Result] = {};
@@ -166,17 +189,22 @@ class DebugCounter {
   // Struct to store counter info.
   struct CounterInfo {
     int64_t Count = 0;
-    int64_t Skip = 0;
-    int64_t StopAfter = -1;
+    uint64_t CurrChunkIdx = 0;
     bool IsSet = false;
     std::string Desc;
+    SmallVector<Chunk> Chunks;
   };
+
   DenseMap<unsigned, CounterInfo> Counters;
   CounterVector RegisteredCounters;
 
   // Whether we should do DebugCounting at all. DebugCounters aren't
   // thread-safe, so this should always be false in multithreaded scenarios.
   bool Enabled = false;
+
+  bool ShouldPrintCounter = false;
+
+  bool BreakOnLast = false;
 };
 
 #define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)                              \

llvm/lib/IR/PassManager.cpp

@@ -8,11 +8,20 @@
 
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PassManagerImpl.h"
+#include "llvm/Support/DebugCounter.h"
 #include <optional>
 
 using namespace llvm;
 
 namespace llvm {
+
+DEBUG_COUNTER(AddNewPMPassCounter, "new-pm-pass-counter",
+              "Control what passes get run");
+
+bool shouldAddNewPMPass() {
+  return DebugCounter::shouldExecute(AddNewPMPassCounter);
+}
+
 // Explicit template instantiations and specialization defininitions for core
 // template typedefs.
 template class AllAnalysesOn<Module>;