[Bugpoint redesign] Output option can now print to STDOUT

[diegotf]

Summary

This also changes all the outs() statements to errs() so the output and
progress streams don't get mixed.

This has been added because D64176 had flaky tests, which I believe were because the reduced file was being catted into FileCheck, instead of being pass from STDOUT directly.

[xbolva00]

llvm/test/Reduce/remove-funcs.ll

4

+1

remove-global-vars.ll needs fix too, please revisit tests..

[diegotf]

llvm/test/Reduce/remove-funcs.ll

4

Yes, I've reverted that commit (I don't know why it didn't reflect on Phabricator). I'll update the other diff accordingly

[xbolva00]

Ok, go ahead.

llvm/test/Reduce/remove-funcs.ll

 ; Test that llvm-reduce can remove uninteresting functions as well as
 ; their InstCalls.
 ;
-; RUN: llvm-reduce --test %p/Inputs/remove-funcs.py %s
-; RUN: cat reduced.ll | FileCheck %s
+; RUN: llvm-reduce --test %p/Inputs/remove-funcs.py %s -o - | FileCheck %s
 ; REQUIRES: plugins, shell
 
 ; CHECK-NOT: uninteresting1()
 define i32 @uninteresting1() {
 entry:
   ret i32 0
 }
 

llvm/tools/llvm-reduce/TestRunner.cpp

for (auto Arg : TestArgs)
     ProgramArgs.push_back(Arg.c_str());
 
   Optional<StringRef> Redirects[3]; // STDIN, STDOUT, STDERR
   int Result = sys::ExecuteAndWait(TestName, ProgramArgs, None, Redirects);
 
   if (Result < 0) {
     Error E = make_error<StringError>("Error running interesting-ness test\n",
                                       inconvertibleErrorCode());
-    outs() << toString(std::move(E));
+    errs() << toString(std::move(E));
     exit(1);
   }
 
   return !Result;
 }

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

 struct Chunk {
   unsigned begin;
   unsigned end;
 
   /// Helper function to verify if a given Target-index is inside the Chunk
   bool contains(unsigned Index) const { return Index >= begin && Index <= end; }
 
   void print() const {
-    outs() << "[" << begin;
+    errs() << "[" << begin;
     if (end - begin != 0)
-      outs() << "," << end;
-    outs() << "]";
+      errs() << "," << end;
+    errs() << "]";
   }
 
   /// Operator when populating CurrentChunks in Generic Delta Pass
   friend bool operator!=(const Chunk &C1, const Chunk &C2) {
     return C1.begin != C2.begin || C1.end != C2.end;
   }
 
   /// Operator used for sets

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

static SmallString<128> createTmpFile(Module *M, StringRef TmpDir) {
 
   if (writeProgramToFile(UniqueFilepath, UniqueFD, *M)) {
     errs() << "Error emitting bitcode to file '" << UniqueFilepath << "'!\n";
     exit(1);
   }
   return UniqueFilepath;
 }
 
-/// Prints the Chunk Indexes with the following format: [start, end], if
-/// chunk is at minimum size (1), then it just displays [start].
-static void printChunks(std::vector<Chunk> Chunks, bool Oneline = false) {
-  if (Chunks.empty()) {
-    outs() << "No Chunks";
-    return;
-  }
-
-  for (auto C : Chunks) {
-    if (!Oneline)
-      outs() << '\t';
-    C.print();
-    if (!Oneline)
-      outs() << '\n';
-  }
-}
-
 /// Counts the amount of lines for a given file
 static unsigned getLines(StringRef Filepath) {
   unsigned Lines = 0;
   std::string CurrLine;
   std::ifstream FileStream(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) {
-  outs() << "Increasing granularity...";
+  errs() << "Increasing granularity...";
   std::vector<Chunk> NewChunks;
   bool SplitOne = false;
 
   for (auto &C : Chunks) {
     if (C.end - C.begin == 0)
       NewChunks.push_back(C);
     else {
       unsigned Half = (C.begin + C.end) / 2;
       NewChunks.push_back({C.begin, Half});
       NewChunks.push_back({Half + 1, C.end});
       SplitOne = true;
     }
   }
   if (SplitOne) {
     Chunks = NewChunks;
-    outs() << "Success! New Chunks:\n";
-    printChunks(Chunks);
+    errs() << "Success! New Chunks:\n";
+    for (auto C : Chunks) {
+      errs() << '\t';
+      C.print();
+      errs() << '\n';
+    }
   }
   return SplitOne;
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test.
 void llvm::runDeltaPass(
     TestRunner &Test, unsigned Targets,
     std::function<void(const std::vector<Chunk> &, Module *)>
         ExtractChunksFromModule) {
   if (!Targets) {
-    outs() << "\nNothing to reduce\n";
+    errs() << "\nNothing to reduce\n";
     return;
   }
   if (!Test.run(Test.getReducedFilepath())) {
-    outs() << "\nInput isn't interesting! Verify interesting-ness test\n";
+    errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
     exit(1);
   }
 
   std::vector<Chunk> Chunks = {{1, Targets}};
   std::set<Chunk> UninterestingChunks;
   std::unique_ptr<Module> ReducedProgram;
 
   if (!increaseGranularity(Chunks)) {
-    outs() << "\nAlready at minimum size. Cannot reduce anymore.\n";
+    errs() << "\nAlready at minimum size. Cannot reduce anymore.\n";
     return;
   }
 
   do {
     UninterestingChunks = {};
     for (int I = Chunks.size() - 1; I >= 0; --I) {
       std::vector<Chunk> CurrentChunks;
 
       for (auto C : Chunks)
         if (!UninterestingChunks.count(C) && C != Chunks[I])
           CurrentChunks.push_back(C);
 
       if (CurrentChunks.empty())
         continue;
 
       // Clone module before hacking it up..
       std::unique_ptr<Module> Clone = CloneModule(*Test.getProgram());
       // Generate Module with only Targets inside Current Chunks
       ExtractChunksFromModule(CurrentChunks, Clone.get());
       // Write Module to tmp file
       SmallString<128> CurrentFilepath =
           createTmpFile(Clone.get(), Test.getTmpDir());
 
-      outs() << "Testing with: ";
-      printChunks(CurrentChunks, /*Oneline=*/true);
-      outs() << " | " << sys::path::filename(CurrentFilepath);
+      errs() << "Ignoring: ";
+      Chunks[I].print();
+      for (auto C : UninterestingChunks)
+        C.print();
+
+      errs() << " | " << sys::path::filename(CurrentFilepath);
 
       // Current Chunks aren't interesting
       if (!Test.run(CurrentFilepath)) {
-        outs() << "\n";
+        errs() << "\n";
         continue;
       }
 
       UninterestingChunks.insert(Chunks[I]);
       Test.setReducedFilepath(CurrentFilepath);
       ReducedProgram = std::move(Clone);
-      outs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n";
+      errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n";
     }
     // Delete uninteresting chunks
     erase_if(Chunks, [&UninterestingChunks](const Chunk &C) {
       return UninterestingChunks.count(C);
     });
 
   } while (!UninterestingChunks.empty() || increaseGranularity(Chunks));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
-  outs() << "Couldn't increase anymore.\n";
+  errs() << "Couldn't increase anymore.\n";
 }
 No newline at end of file

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

static void extractFunctionsFromModule(const std::vector<Chunk> &ChunksToKeep,
   for (auto *F : FuncsToRemove)
     F->eraseFromParent();
 }
 
 /// Counts the amount of non-declaration functions and prints their
 /// respective name & index
 static unsigned countFunctions(Module *Program) {
   // TODO: Silence index with --quiet flag
-  outs() << "----------------------------\n";
-  outs() << "Function Index Reference:\n";
+  errs() << "----------------------------\n";
+  errs() << "Function Index Reference:\n";
   unsigned FunctionCount = 0;
   for (auto &F : *Program)
-    outs() << "\t" << ++FunctionCount << ": " << F.getName() << "\n";
+    errs() << "\t" << ++FunctionCount << ": " << F.getName() << "\n";
 
-  outs() << "----------------------------\n";
+  errs() << "----------------------------\n";
   return FunctionCount;
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Functions...\n";
+  errs() << "*** Reducing Functions...\n";
   unsigned Functions = countFunctions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionsFromModule);
-  outs() << "----------------------------\n";
+  errs() << "----------------------------\n";
 }
 No newline at end of file

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

int main(int argc, char **argv) {
   TestRunner Tester(TestFilename, TestArguments, InputFilename);
   Tester.setProgram(std::move(OriginalProgram));
 
   // Try to reduce code
   runDeltaPasses(Tester);
   StringRef ReducedFilename = sys::path::filename(Tester.getReducedFilepath());
 
   if (ReducedFilename == sys::path::filename(InputFilename)) {
-    outs() << "\nCouldnt reduce input :/\n";
+    errs() << "\nCouldnt reduce input :/\n";
   } else {
+    // Print reduced file to STDOUT
+    if (OutputFilename == "-")
+      Tester.getProgram()->print(outs(), nullptr);
+    else {
       if (ReplaceInput) // In-place
         OutputFilename = InputFilename.c_str();
       else if (OutputFilename.empty())
         OutputFilename = "reduced.ll";
       else
         OutputFilename += ".ll";
 
       sys::fs::copy_file(Tester.getReducedFilepath(), OutputFilename);
-    outs() << "\nDone reducing! Reduced IR to file: " << OutputFilename << "\n";
+      errs() << "\nDone reducing! Reduced testcase: " << OutputFilename << "\n";
+    }
   }
 
   return 0;
 }