[opt] Remove obsolete --quiet option

[aeubanks]

Summary

git blame shows these were last touched in 2004?

[hans]

llvm/lib/Support/SystemUtils.cpp

20

nit: the indentation needs readjusting

llvm/tools/opt/PassPrinters.cpp

75

nit: indent

110

indent

140

indent

171

indent

llvm/tools/opt/opt.cpp

208

Might be worth mentioning the option was "neutered" in r13844

[aeubanks]

Format (not sure why git clang-format didn't work)

llvm/include/llvm/Support/SystemUtils.h

 
 namespace llvm {
   class raw_ostream;
 
 /// Determine if the raw_ostream provided is connected to a terminal. If so,
 /// generate a warning message to errs() advising against display of bitcode
 /// and return true. Otherwise just return false.
 /// Check for output written to a console
   bool CheckBitcodeOutputToConsole(
-  raw_ostream &stream_to_check, ///< The stream to be checked
-  bool print_warning = true     ///< Control whether warnings are printed
+      raw_ostream &stream_to_check ///< The stream to be checked
   );
 
 } // End llvm namespace
 
 #endif

llvm/lib/Support/SystemUtils.cpp

 // system-specific, tasks.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
-bool llvm::CheckBitcodeOutputToConsole(raw_ostream &stream_to_check,
-                                       bool print_warning) {
+bool llvm::CheckBitcodeOutputToConsole(raw_ostream &stream_to_check) {
   if (stream_to_check.is_displayed()) {
-    if (print_warning) {
       errs() << "WARNING: You're attempting to print out a bitcode file.\n"
                 "This is inadvisable as it may cause display problems. If\n"
                 "you REALLY want to taste LLVM bitcode first-hand, you\n"
                 "can force output with the `-f' option.\n\n";
-    }
     return true;
   }
   return false;
 }

llvm/tools/llvm-as/llvm-as.cpp

static void WriteOutputFile(const Module *M, const ModuleSummaryIndex *Index) {
   std::error_code EC;
   std::unique_ptr<ToolOutputFile> Out(
       new ToolOutputFile(OutputFilename, EC, sys::fs::OF_None));
   if (EC) {
     errs() << EC.message() << '\n';
     exit(1);
   }
 
-  if (Force || !CheckBitcodeOutputToConsole(Out->os(), true)) {
+  if (Force || !CheckBitcodeOutputToConsole(Out->os())) {
     const ModuleSummaryIndex *IndexToWrite = nullptr;
     // Don't attempt to write a summary index unless it contains any entries or
     // has non-zero flags. The latter is used to assemble dummy index files for
     // skipping modules by distributed ThinLTO backends. Otherwise we get an empty
     // summary section.
     if (Index && (Index->begin() != Index->end() || Index->getFlags()))
       IndexToWrite = Index;
     if (!IndexToWrite || (M && (!M->empty() || !M->global_empty())))

llvm/tools/llvm-extract/llvm-extract.cpp

int main(int argc, char **argv) {
   if (EC) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   if (OutputAssembly)
     Passes.add(
         createPrintModulePass(Out.os(), "", PreserveAssemblyUseListOrder));
-  else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
+  else if (Force || !CheckBitcodeOutputToConsole(Out.os()))
     Passes.add(createBitcodeWriterPass(Out.os(), PreserveBitcodeUseListOrder));
 
   Passes.run(*M.get());
 
   // Declare success.
   Out.keep();
 
   return 0;
 }

llvm/tools/llvm-link/llvm-link.cpp

if (verifyModule(*Composite, &errs())) {
     WithColor::error() << "linked module is broken!\n";
     return 1;
   }
 
   if (Verbose)
     errs() << "Writing bitcode...\n";
   if (OutputAssembly) {
     Composite->print(Out.os(), nullptr, PreserveAssemblyUseListOrder);
-  } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
+  } else if (Force || !CheckBitcodeOutputToConsole(Out.os()))
     WriteBitcodeToFile(*Composite, Out.os(), PreserveBitcodeUseListOrder);
 
   // Declare success.
   Out.keep();
 
   return 0;
 }

llvm/tools/opt/PassPrinters.h

 class CallGraphSCCPass;
 class FunctionPass;
 class ModulePass;
 class LoopPass;
 class PassInfo;
 class raw_ostream;
 class RegionPass;
 
-FunctionPass *createFunctionPassPrinter(const PassInfo *PI, raw_ostream &out,
-                                        bool Quiet);
+FunctionPass *createFunctionPassPrinter(const PassInfo *PI, raw_ostream &out);
 
 CallGraphSCCPass *createCallGraphPassPrinter(const PassInfo *PI,
-                                             raw_ostream &out, bool Quiet);
+                                             raw_ostream &out);
 
-ModulePass *createModulePassPrinter(const PassInfo *PI, raw_ostream &out,
-                                    bool Quiet);
+ModulePass *createModulePassPrinter(const PassInfo *PI, raw_ostream &out);
 
-LoopPass *createLoopPassPrinter(const PassInfo *PI, raw_ostream &out,
-                                bool Quiet);
+LoopPass *createLoopPassPrinter(const PassInfo *PI, raw_ostream &out);
 
-RegionPass *createRegionPassPrinter(const PassInfo *PI, raw_ostream &out,
-                                    bool Quiet);
+RegionPass *createRegionPassPrinter(const PassInfo *PI, raw_ostream &out);
 
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OPT_PASSPRINTERS_H

llvm/tools/opt/PassPrinters.cpp

 
 namespace {
 
 struct FunctionPassPrinter : public FunctionPass {
   const PassInfo *PassToPrint;
   raw_ostream &Out;
   static char ID;
   std::string PassName;
-  bool QuietPass;
 
-  FunctionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : FunctionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
+  FunctionPassPrinter(const PassInfo *PI, raw_ostream &out)
+      : FunctionPass(ID), PassToPrint(PI), Out(out) {
     std::string PassToPrintName = std::string(PassToPrint->getPassName());
     PassName = "FunctionPass Printer: " + PassToPrintName;
   }
 
   bool runOnFunction(Function &F) override {
-    if (!QuietPass)
-      Out << "Printing analysis '" << PassToPrint->getPassName()
-          << "' for function '" << F.getName() << "':\n";
 
     // Get and print pass...
     getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, F.getParent());
     return false;
   }
 
   StringRef getPassName() const override { return PassName; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(PassToPrint->getTypeInfo());
     AU.setPreservesAll();
   }
 };
 
 char FunctionPassPrinter::ID = 0;
 
 struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
   static char ID;
   const PassInfo *PassToPrint;
   raw_ostream &Out;
   std::string PassName;
-  bool QuietPass;
 
-  CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : CallGraphSCCPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
+  CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out)
+      : CallGraphSCCPass(ID), PassToPrint(PI), Out(out) {
     std::string PassToPrintName = std::string(PassToPrint->getPassName());
     PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
   }
 
   bool runOnSCC(CallGraphSCC &SCC) override {
-    if (!QuietPass)
       Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 
     // Get and print pass...
     for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
       Function *F = (*I)->getFunction();
       if (F)
         getAnalysisID<Pass>(PassToPrint->getTypeInfo())
             .print(Out, F->getParent());
     }

 
 char CallGraphSCCPassPrinter::ID = 0;
 
 struct ModulePassPrinter : public ModulePass {
   static char ID;
   const PassInfo *PassToPrint;
   raw_ostream &Out;
   std::string PassName;
-  bool QuietPass;
 
-  ModulePassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : ModulePass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
+  ModulePassPrinter(const PassInfo *PI, raw_ostream &out)
+      : ModulePass(ID), PassToPrint(PI), Out(out) {
     std::string PassToPrintName = std::string(PassToPrint->getPassName());
     PassName = "ModulePass Printer: " + PassToPrintName;
   }
 
   bool runOnModule(Module &M) override {
-    if (!QuietPass)
       Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 
     // Get and print pass...
     getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
     return false;
   }
 
   StringRef getPassName() const override { return PassName; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(PassToPrint->getTypeInfo());
     AU.setPreservesAll();
   }
 };
 
 char ModulePassPrinter::ID = 0;
 
 struct LoopPassPrinter : public LoopPass {
   static char ID;
   const PassInfo *PassToPrint;
   raw_ostream &Out;
   std::string PassName;
-  bool QuietPass;
 
-  LoopPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : LoopPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
+  LoopPassPrinter(const PassInfo *PI, raw_ostream &out)
+      : LoopPass(ID), PassToPrint(PI), Out(out) {
     std::string PassToPrintName = std::string(PassToPrint->getPassName());
     PassName = "LoopPass Printer: " + PassToPrintName;
   }
 
   bool runOnLoop(Loop *L, LPPassManager &LPM) override {
-    if (!QuietPass)
       Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 
     // Get and print pass...
     getAnalysisID<Pass>(PassToPrint->getTypeInfo())
         .print(Out, L->getHeader()->getParent()->getParent());
     return false;
   }
 
   StringRef getPassName() const override { return PassName; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(PassToPrint->getTypeInfo());
     AU.setPreservesAll();
   }
 };
 
 char LoopPassPrinter::ID = 0;
 
 struct RegionPassPrinter : public RegionPass {
   static char ID;
   const PassInfo *PassToPrint;
   raw_ostream &Out;
   std::string PassName;
-  bool QuietPass;
 
-  RegionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
-      : RegionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
+  RegionPassPrinter(const PassInfo *PI, raw_ostream &out)
+      : RegionPass(ID), PassToPrint(PI), Out(out) {
     std::string PassToPrintName = std::string(PassToPrint->getPassName());
     PassName = "RegionPass Printer: " + PassToPrintName;
   }
 
   bool runOnRegion(Region *R, RGPassManager &RGM) override {
-    if (!QuietPass) {
       Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
           << "region: '" << R->getNameStr() << "' in function '"
           << R->getEntry()->getParent()->getName() << "':\n";
-    }
     // Get and print pass...
     getAnalysisID<Pass>(PassToPrint->getTypeInfo())
         .print(Out, R->getEntry()->getParent()->getParent());
     return false;
   }
 
   StringRef getPassName() const override { return PassName; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(PassToPrint->getTypeInfo());
     AU.setPreservesAll();
   }
 };
 
 char RegionPassPrinter::ID = 0;
 
 } // end anonymous namespace
 
 FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
-                                              raw_ostream &OS, bool Quiet) {
-  return new FunctionPassPrinter(PI, OS, Quiet);
+                                              raw_ostream &OS) {
+  return new FunctionPassPrinter(PI, OS);
 }
 
 CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
-                                                   raw_ostream &OS,
-                                                   bool Quiet) {
-  return new CallGraphSCCPassPrinter(PI, OS, Quiet);
+                                                   raw_ostream &OS) {
+  return new CallGraphSCCPassPrinter(PI, OS);
 }
 
-ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS,
-                                          bool Quiet) {
-  return new ModulePassPrinter(PI, OS, Quiet);
+ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS) {
+  return new ModulePassPrinter(PI, OS);
 }
 
-LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS,
-                                      bool Quiet) {
-  return new LoopPassPrinter(PI, OS, Quiet);
+LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS) {
+  return new LoopPassPrinter(PI, OS);
 }
 
-RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS,
-                                          bool Quiet) {
-  return new RegionPassPrinter(PI, OS, Quiet);
+RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS) {
+  return new RegionPassPrinter(PI, OS);
 }
-

llvm/tools/opt/opt.cpp

 DisableSimplifyLibCalls("disable-simplify-libcalls",
                         cl::desc("Disable simplify-libcalls"));
 
 static cl::list<std::string>
 DisableBuiltins("disable-builtin",
                 cl::desc("Disable specific target library builtin function"),
                 cl::ZeroOrMore);
 
-
-static cl::opt<bool>
-Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
-
-static cl::alias
-QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
-
 static cl::opt<bool>
 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
 
 static cl::opt<bool> EnableDebugify(
     "enable-debugify",
     cl::desc(
         "Start the pipeline with debugify and end it with check-debugify"));
 
#endif
   // Override function attributes based on CPUStr, FeaturesStr, and command line
   // flags.
   codegen::setFunctionAttributes(CPUStr, FeaturesStr, *M);
 
   // If the output is set to be emitted to standard out, and standard out is a
   // console, print out a warning message and refuse to do it.  We don't
   // impress anyone by spewing tons of binary goo to a terminal.
   if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
-    if (CheckBitcodeOutputToConsole(Out->os(), !Quiet))
+    if (CheckBitcodeOutputToConsole(Out->os()))
       NoOutput = true;
 
   if (OutputThinLTOBC)
     M->addModuleFlag(Module::Error, "EnableSplitLTOUnit", SplitLTOUnit);
 
   if (EnableNewPassManager || PassPipeline.getNumOccurrences() > 0) {
     if (PassPipeline.getNumOccurrences() > 0 && PassList.size() > 0) {
       errs()
else
              << PassInf->getPassName() << "\n";
     if (P) {
       PassKind Kind = P->getPassKind();
       addPass(Passes, P);
 
       if (AnalyzeOnly) {
         switch (Kind) {
         case PT_Region:
-          Passes.add(createRegionPassPrinter(PassInf, Out->os(), Quiet));
+          Passes.add(createRegionPassPrinter(PassInf, Out->os()));
           break;
         case PT_Loop:
-          Passes.add(createLoopPassPrinter(PassInf, Out->os(), Quiet));
+          Passes.add(createLoopPassPrinter(PassInf, Out->os()));
           break;
         case PT_Function:
-          Passes.add(createFunctionPassPrinter(PassInf, Out->os(), Quiet));
+          Passes.add(createFunctionPassPrinter(PassInf, Out->os()));
           break;
         case PT_CallGraphSCC:
-          Passes.add(createCallGraphPassPrinter(PassInf, Out->os(), Quiet));
+          Passes.add(createCallGraphPassPrinter(PassInf, Out->os()));
           break;
         default:
-          Passes.add(createModulePassPrinter(PassInf, Out->os(), Quiet));
+          Passes.add(createModulePassPrinter(PassInf, Out->os()));
           break;
         }
       }
     }
 
     if (PrintEachXForm)
       Passes.add(
           createPrintModulePass(errs(), "", PreserveAssemblyUseListOrder));