[llvm-reduce] Move most debugging output behind --verbose

[aeubanks]

Summary

This should cut down on the visual noise when reducing. Still keep output when we run a pass or when we successfully reduce.

Notably, this also suppresses redirecting the test output to stdout/stderr.

[regehr]

I like this -- especially the part that gets rid of the interestingness test's output

I would prefer to leave the "reduction resulted in invalid module" which is useful because it sometimes is followed by a segfault, and helps provide context about why the segfault happened, but I don't feel strongly about that. I mean it's not hard to re-launch a reduction in verbose mode if llvm-reduce crashes.

llvm/tools/llvm-reduce/TestRunner.cpp

 //===-- TestRunner.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestRunner.h"
 #include "ReducerWorkItem.h"
-#include "llvm/CodeGen/MachineFunction.h"
+#include "deltas/Utils.h"
 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
                        std::unique_ptr<ReducerWorkItem> Program,
                        std::unique_ptr<TargetMachine> TM, const char *ToolName)
     : TestName(TestName), ToolName(ToolName), TestArgs(TestArgs),
       Program(std::move(Program)), TM(std::move(TM)) {
   assert(this->Program && "Initialized with null program?");
 }
 
 /// Runs the interestingness test, passes file to be tested as first argument
 /// and other specified test arguments after that.
 int TestRunner::run(StringRef Filename) {
   std::vector<StringRef> ProgramArgs;
   ProgramArgs.push_back(TestName);
 
   for (const auto &Arg : TestArgs)
     ProgramArgs.push_back(Arg);
 
   ProgramArgs.push_back(Filename);
 
   std::string ErrMsg;
-  int Result = sys::ExecuteAndWait(
-      TestName, ProgramArgs, /*Env=*/None, /*Redirects=*/None,
+  SmallVector<Optional<StringRef>, 3> Redirects;
+  Optional<StringRef> Empty = StringRef();
+  if (!Verbose) {
+    for (int i = 0; i < 3; ++i)
+      Redirects.push_back(Empty);
+  }
+  int Result =
+      sys::ExecuteAndWait(TestName, ProgramArgs, /*Env=*/None, Redirects,
                           /*SecondsToWait=*/0, /*MemoryLimit=*/0, &ErrMsg);
 
   if (Result < 0) {
     Error E = make_error<StringError>("Error running interesting-ness test: " +
                                           ErrMsg,
                                       inconvertibleErrorCode());
     errs() << toString(std::move(E));
     exit(1);
   }
 
   return !Result;
 }
 
 void TestRunner::setProgram(std::unique_ptr<ReducerWorkItem> P) {
   assert(P && "Setting null program?");
   Program = std::move(P);
 }

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

 //===- Delta.cpp - Delta Debugging Algorithm Implementation ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation for the Delta Debugging Algorithm:
 // it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.)
 // into chunks and tries to reduce the number chunks that are interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Delta.h"
 #include "ReducerWorkItem.h"
+#include "Utils.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBufferRef.h"
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;
 
   for (auto &C : Chunks) {
     if (C.End - C.Begin == 0)
       NewChunks.push_back(C);
     else {
       int 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;
+    if (Verbose) {
       errs() << "Success! New Chunks:\n";
       for (auto C : Chunks) {
         errs() << '\t';
         C.print();
         errs() << '\n';
       }
     }
+  }
   return SplitOne;
 }
 
 // Check if \p ChunkToCheckForUninterestingness is interesting. Returns the
 // modified module if the chunk resulted in a reduction.
 template <typename FuncType>
 static std::unique_ptr<ReducerWorkItem>
 CheckChunk(Chunk &ChunkToCheckForUninterestingness,
CheckChunk(Chunk &ChunkToCheckForUninterestingness,
 
   // Some reductions may result in invalid IR. Skip such reductions.
   if (verifyReducerWorkItem(*Clone, &errs())) {
     if (AbortOnInvalidReduction) {
       errs() << "Invalid reduction, aborting.\n";
       Clone->print(errs());
       exit(1);
     }
+    if (Verbose) {
       errs() << " **** WARNING | reduction resulted in invalid module, "
                 "skipping\n";
+    }
     return nullptr;
   }
 
+  if (Verbose) {
     errs() << "Ignoring: ";
     ChunkToCheckForUninterestingness.print();
     for (const Chunk &C : UninterestingChunks)
       C.print();
+    errs() << "\n";
+  }
 
   SmallString<128> CurrentFilepath;
   if (!isReduced(*Clone, Test, CurrentFilepath)) {
     // Program became non-reduced, so this chunk appears to be interesting.
+    if (Verbose)
       errs() << "\n";
     return nullptr;
   }
   return Clone;
 }
 
 template <typename FuncType>
 SmallString<0> ProcessChunkFromSerializedBitcode(
     Chunk &ChunkToCheckForUninterestingness, TestRunner &Test,
#ifndef NDEBUG
     std::unique_ptr<ReducerWorkItem> Clone =
         cloneReducerWorkItem(Test.getProgram(), Test.getTargetMachine());
     ExtractChunksFromModule(NoChunksCounter, *Clone);
     assert(Targets == NoChunksCounter.count() &&
            "number of chunks changes when reducing");
 #endif
   }
   if (!Targets) {
+    if (Verbose)
       errs() << "\nNothing to reduce\n";
     return;
   }
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{0, Targets - 1}};
   std::unique_ptr<ReducerWorkItem> ReducedProgram;
 
   for (unsigned int Level = 0; Level < StartingGranularityLevel; Level++) {
     increaseGranularity(ChunksStillConsideredInteresting);
for (auto I = ChunksStillConsideredInteresting.rbegin(),
 
       if (!Result)
         continue;
 
       Chunk &ChunkToCheckForUninterestingness = *I;
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);
       ReducedProgram = std::move(Result);
-      errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n";
+      if (Verbose)
+        errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath)
+               << "\n";
       writeOutput(*ReducedProgram, "Saved new best reduction to ");
     }
     // Delete uninteresting chunks
     erase_if(ChunksStillConsideredInteresting,
              [&UninterestingChunks](const Chunk &C) {
                return UninterestingChunks.count(C);
              });
   } while (!ChunksStillConsideredInteresting.empty() &&
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||
             increaseGranularity(ChunksStillConsideredInteresting)));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
+  if (Verbose)
     errs() << "Couldn't increase anymore.\n";
 }

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_UTILS_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_UTILS_H
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
+extern cl::opt<bool> Verbose;
+
 Value *getDefaultValue(Type *T);
 bool hasAliasUse(Function &F);
 
 } // namespace llvm
 
 #endif

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

 //===----------------------------------------------------------------------===//
 
 #include "Utils.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalAlias.h"
 
 using namespace llvm;
 
+extern cl::OptionCategory LLVMReduceOptions;
+
+cl::opt<bool> llvm::Verbose("verbose",
+                            cl::desc("Print extra debugging information"),
+                            cl::init(false), cl::cat(LLVMReduceOptions));
+
 Value *llvm::getDefaultValue(Type *T) {
   return T->isVoidTy() ? PoisonValue::get(T) : Constant::getNullValue(T);
 }
 
 bool llvm::hasAliasUse(Function &F) {
   return any_of(F.users(), [](User *U) { return isa<GlobalAlias>(U); });
 }