llvm-reduce: Stop checking workitem is interesting before each pass

[arsenm]

Summary

Each delta pass run should have guaranteed the output is still
interesting, so it should be pointless to recheck this each
iteration. I have many issues that take multiple minutes
to reproduce, so this ends up being a huge waste of time.

Also, remove broken line counting. This never worked, since
getLines was failing to open the temporary file which was just
deleted.

[arsenm]

f041204ec896a24d19f44b9095660ab8559ebbc7

llvm/tools/llvm-reduce/deltas/Delta.cpp

 
 void writeOutput(ReducerWorkItem &M, llvm::StringRef Message);
 
 void writeBitcode(ReducerWorkItem &M, raw_ostream &OutStream);
 
 void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx,
                  const char *ToolName);
 
-bool isReduced(ReducerWorkItem &M, TestRunner &Test,
-               SmallString<128> &CurrentFilepath) {
+bool isReduced(ReducerWorkItem &M, TestRunner &Test) {
+  SmallString<128> CurrentFilepath;
   // Write ReducerWorkItem to tmp file
   int FD;
   std::error_code EC = sys::fs::createTemporaryFile(
       "llvm-reduce", M.isMIR() ? "mir" : (TmpFilesAsBitcode ? "bc" : "ll"), FD,
       CurrentFilepath);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "!\n";
     exit(1);
errs() << "Error emitting bitcode to file '" << CurrentFilepath
            << "': " << Out.os().error().message();
     exit(1);
   }
 
   // Current Chunks aren't interesting
   return Test.run(CurrentFilepath);
 }
 
-/// Counts the amount of lines for a given file
-static int getLines(StringRef Filepath) {
-  int Lines = 0;
-  std::string CurrLine;
-  std::ifstream FileStream{std::string(Filepath)};
-
-  while (std::getline(FileStream, CurrLine))
-    ++Lines;
-
-  return Lines;
-}
-
 /// Splits Chunks in half and prints them.
 /// If unable to split (when chunk size is 1) returns false.
 static bool increaseGranularity(std::vector<Chunk> &Chunks) {
   if (Verbose)
     errs() << "Increasing granularity...";
   std::vector<Chunk> NewChunks;
   bool SplitOne = false;
 
CheckChunk(Chunk &ChunkToCheckForUninterestingness,
   if (Verbose) {
     errs() << "Ignoring: ";
     ChunkToCheckForUninterestingness.print();
     for (const Chunk &C : UninterestingChunks)
       C.print();
     errs() << "\n";
   }
 
-  SmallString<128> CurrentFilepath;
-  if (!isReduced(*Clone, Test, CurrentFilepath)) {
+  if (!isReduced(*Clone, Test)) {
     // Program became non-reduced, so this chunk appears to be interesting.
     if (Verbose)
       errs() << "\n";
     return nullptr;
   }
   return Clone;
 }
 

 /// given test. The number of chunks is determined by a preliminary run of the
 /// reduction pass where no change must be made to the module.
 void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
                         StringRef Message) {
   assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
          "input module is broken before making changes");
   errs() << "*** " << Message << "...\n";
 
-  SmallString<128> CurrentFilepath;
-  if (!isReduced(Test.getProgram(), Test, CurrentFilepath)) {
-    errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
-    exit(1);
-  }
-
   int Targets;
   {
     // Count the number of chunks by counting the number of calls to
     // Oracle::shouldKeep() but always returning true so no changes are
     // made.
     std::vector<Chunk> AllChunks = {{0, INT_MAX}};
     Oracle Counter(AllChunks);
     ExtractChunksFromModule(Counter, Test.getProgram());
     Targets = Counter.count();
 
     assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
            "input module is broken after counting chunks");
-    assert(isReduced(Test.getProgram(), Test, CurrentFilepath) &&
+    assert(isReduced(Test.getProgram(), Test) &&
            "input module no longer interesting after counting chunks");
 
 #ifndef NDEBUG
     // Make sure that the number of chunks does not change as we reduce.
     std::vector<Chunk> NoChunks = {{0, INT_MAX}};
     Oracle NoChunksCounter(NoChunks);
     std::unique_ptr<ReducerWorkItem> Clone =
         cloneReducerWorkItem(Test.getProgram(), Test.getTargetMachine());
for (auto I = ChunksStillConsideredInteresting.rbegin(),
 
       if (!Result)
         continue;
 
       Chunk &ChunkToCheckForUninterestingness = *I;
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);
       ReducedProgram = std::move(Result);
-      if (Verbose)
-        errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath)
-               << "\n";
-      writeOutput(*ReducedProgram, "Saved new best reduction to ");
+
+      // FIXME: Report meaningful progress info
+      writeOutput(*ReducedProgram, " **** SUCCESS | Saved new best reduction to ");
     }
     // Delete uninteresting chunks
     erase_if(ChunksStillConsideredInteresting,
              [&UninterestingChunks](const Chunk &C) {
                return UninterestingChunks.count(C);
              });
   } while (!ChunksStillConsideredInteresting.empty() &&
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||

llvm/tools/llvm-reduce/llvm-reduce.cpp

 static cl::opt<int>
     MaxPassIterations("max-pass-iterations",
                       cl::desc("Maximum number of times to run the full set "
                                "of delta passes (default=5)"),
                       cl::init(5), cl::cat(LLVMReduceOptions));
 
 static codegen::RegisterCodeGenFlags CGF;
 
+bool isReduced(ReducerWorkItem &M, TestRunner &Test);
+
 void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
     OutputFilename = M.isMIR() ? "reduced.mir" : "reduced.ll";
   std::error_code EC;
   raw_fd_ostream Out(OutputFilename, EC);
   if (EC) {
int main(int Argc, char **Argv) {
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram),
                     std::move(TM), Argv[0]);
 
+  // This parses and writes out the testcase into a temporary file copy for the
+  // test, rather than evaluating the source IR directly. This is for the
+  // convenience of lit tests; the stripped out comments may have broken the
+  // interestingness checks.
+  if (!isReduced(Tester.getProgram(), Tester)) {
+    errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
+    return 1;
+  }
+
   // Try to reduce code
   runDeltaPasses(Tester, MaxPassIterations);
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
     writeOutput(Tester.getProgram(), "Done reducing! Reduced testcase: ");
 
   return 0;
 }