Don't call exit from cl::PrintHelpMessage();

[ruiu]

LGTM

lib/Support/CommandLine.cpp

2104–2111

Thank you for doing this. This is much easier to understand than before. The previous code was too magical.

include/llvm/Support/CommandLine.h

struct extrahelp {
   explicit extrahelp(StringRef help);
 };
 
 void PrintVersionMessage();
 
 /// This function just prints the help message, exactly the same way as if the
 /// -help or -help-hidden option had been given on the command line.
 ///
-/// NOTE: THIS FUNCTION TERMINATES THE PROGRAM!
-///
 /// \param Hidden if true will print hidden options
 /// \param Categorized if true print options in categories
 void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
 
 //===----------------------------------------------------------------------===//
 // Public interface for accessing registered options.
 //
 

lib/Support/CommandLine.cpp

 public:
   explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
   virtual ~HelpPrinter() {}
 
   // Invoke the printer.
   void operator=(bool Value) {
     if (!Value)
       return;
+    printHelp();
 
+    // Halt the program since help information was printed
+    exit(0);
+  }
+
+  void printHelp() {
     SubCommand *Sub = GlobalParser->getActiveSubCommand();
     auto &OptionsMap = Sub->OptionsMap;
     auto &PositionalOpts = Sub->PositionalOpts;
     auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
 
     StrOptionPairVector Opts;
     sortOpts(OptionsMap, Opts, ShowHidden);
 
void printHelp() {
 
     outs() << "OPTIONS:\n";
     printOptions(Opts, MaxArgLen);
 
     // Print any extra help the user has declared.
     for (auto I : GlobalParser->MoreHelp)
       outs() << I;
     GlobalParser->MoreHelp.clear();
-
-    // Halt the program since help information was printed
-    exit(0);
   }
 };
 
 class CategorizedHelpPrinter : public HelpPrinter {
 public:
   explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
 
   // Helper function for printOptions().

 
 static cl::opt<VersionPrinter, true, parser<bool>>
     VersOp("version", cl::desc("Display the version of this program"),
            cl::location(VersionPrinterInstance), cl::ValueDisallowed,
            cl::cat(GenericCategory));
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
-  // This looks weird, but it actually prints the help message. The Printers are
-  // types of HelpPrinter and the help gets printed when its operator= is
-  // invoked. That's because the "normal" usages of the help printer is to be
-  // assigned true/false depending on whether -help or -help-hidden was given or
-  // not.  Since we're circumventing that we have to make it look like -help or
-  // -help-hidden were given, so we assign true.
-
   if (!Hidden && !Categorized)
-    UncategorizedNormalPrinter = true;
+    UncategorizedNormalPrinter.printHelp();
   else if (!Hidden && Categorized)
-    CategorizedNormalPrinter = true;
+    CategorizedNormalPrinter.printHelp();
   else if (Hidden && !Categorized)
-    UncategorizedHiddenPrinter = true;
+    UncategorizedHiddenPrinter.printHelp();
   else
-    CategorizedHiddenPrinter = true;
+    CategorizedHiddenPrinter.printHelp();
 }
 
 /// Utility function for printing version number.
 void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
 
 void cl::SetVersionPrinter(VersionPrinterTy func) { OverrideVersionPrinter = func; }
 
 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {

test/tools/llvm-ar/invalid-command-line.test

 Test that llvm-ar exits with 1 when there is an error.
 
 RUN: not llvm-ar e 2>&1 | FileCheck %s
 CHECK: unknown option e.
+CHECK: OVERVIEW: LLVM Archiver (llvm-ar)

tools/dsymutil/dsymutil.cpp

int main(int argc, char **argv) {
   HideUnrelatedOptions(DsymCategory);
   llvm::cl::ParseCommandLineOptions(
       argc, argv,
       "manipulate archived DWARF debug symbol files.\n\n"
       "dsymutil links the DWARF debug information found in the object files\n"
       "for the executable <input file> by using debug symbols information\n"
       "contained in its symbol table.\n");
 
-  if (Help)
+  if (Help) {
     PrintHelpMessage();
+    return 0;
+  }
 
   if (Version) {
     llvm::cl::PrintVersionMessage();
     return 0;
   }
 
   Options.Verbose = Verbose;
   Options.NoOutput = NoOutput;

tools/llvm-ar/llvm-ar.cpp

 using namespace llvm;
 
 // The name this program was invoked as.
 static StringRef ToolName;
 
 // Show the error message and exit.
 LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) {
   errs() << ToolName << ": " << Error << ".\n";
-  // FIXME: Other ar implementations will print the command line help in here.
-  // Unfortunately cl::PrintHelpMessage() exits with 0, so we can't call it.
+  cl::PrintHelpMessage();
   exit(1);
 }
 
 static void failIfError(std::error_code EC, Twine Context = "") {
   if (!EC)
     return;
 
   std::string ContextStr = Context.str();

tools/llvm-opt-report/OptReport.cpp

int main(int argc, const char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   cl::HideUnrelatedOptions(OptReportCategory);
   cl::ParseCommandLineOptions(
       argc, argv,
       "A tool to generate an optimization report from YAML optimization"
       " record files.\n");
 
-  if (Help)
+  if (Help) {
     cl::PrintHelpMessage();
+    return 0;
+  }
 
   LocationInfoTy LocationInfo;
   if (!readLocationInfo(LocationInfo))
     return 1;
   if (!writeReport(LocationInfo))
     return 1; 
 
   return 0;
 }
 

tools/llvm-xray/llvm-xray.cc

if (*SC) {
         ExitOnError("llvm-xray: ")(C());
         return 0;
       }
     }
   }
 
   // If all else fails, we still print the usage message.
   cl::PrintHelpMessage(false, true);
+  return 0;
 }