[CommandLineParser] Add DefaultOption flag

[hintonda]

Summary

Add DefaultOption flag to CommandLineParser which provides a default option or alias, but allows users to override it for some other purpose as needed.

Also, add -h as a default alias to -help, which can be seamlessly overridden by applications like llvm-objdump and llvm-readobj which use -h as an alias for other options.

[hintonda]

A better alternative would have been to add a cl::aliasopt for '-h' in llvm's CommandLineParser when '-help' was first added. However, that's no longer possible since some llvm based tools already use '-h' for other purposes.

[hintonda]

@arphaman, since you added the -h option in D37618, could you let me know if this change is okay with you?

[alexfh]

Can you give a specific example of how this problem manifests?

[hintonda]

In D59746#1456115, @alexfh wrote:

Can you give a specific example of how this problem manifests?

Any tool using tooling::CommonOptionsParser with the llvm::cl::OneOrMore flag will have this problem, i.e., the -h flag will be seen, but no action taken because it was never wired up. Please note that we changed clang-tidy to use cl::ZeroOrMore a few years ago, so it'll spit out help with or without any arguments, including -h. However, if you pass a bad argument with -h you'll get an error, but no help.

Here are a few you can verify (first try with -h, then -help):

$ bin/clang-tidy -h -x
LLVM ERROR: CommonOptionsParser: failed to parse command-line arguments. [CommonOptionsParser]: clang-tidy: Unknown command line argument '-x'.  Try: 'bin/clang-tidy -help'
clang-tidy: Did you mean '-h'?

$ bin/clang-tidy -help -x
USAGE: clang-tidy [options] <source0> [... <sourceN>]
<snip>


$ bin/clang-refactor -h
error: no refactoring action given
note: the following actions are supported:
  local-rename
  extract

$ bin/clang-refactor -help
OVERVIEW: Clang-based refactoring tool for C, C++ and Objective-C
USAGE: clang-refactor [options] <source0> [... <sourceN>]
<snip>


$ bin/clang-apply-replacements -h
clang-apply-replacements: Unknown command line argument '-h'.  Try: 'bin/clang-apply-replacements -help'
clang-apply-replacements: Did you mean '-help'?
clang-apply-replacements: Not enough positional command line arguments specified!
Must specify at least 1 positional argument: See: bin/clang-apply-replacements -help

$ bin/clang-apply-replacements -help
USAGE: clang-apply-replacements [options] <Search Root Directory>
<snip>


$ bin/clang-change-namespace -h
clang-change-namespace: for the -old_namespace option: must be specified at least once!
clang-change-namespace: for the -new_namespace option: must be specified at least once!
clang-change-namespace: for the -file_pattern option: must be specified at least once!
LLVM ERROR: CommonOptionsParser: failed to parse command-line arguments. [CommonOptionsParser]: clang-change-namespace: Not enough positional command line arguments specified!
Must specify at least 1 positional argument: See: bin/clang-change-namespace -help

$ bin/clang-change-namespace -help
USAGE: clang-change-namespace [options] <source0> [... <sourceN>]
<snip>

[klimek]

In D59746#1440756, @hintonda wrote:

A better alternative would have been to add a cl::aliasopt for '-h' in llvm's CommandLineParser when '-help' was first added. However, that's no longer possible since some llvm based tools already use '-h' for other purposes.

Is that intentional? Can you point at samples?

[hintonda]

In D59746#1458086, @klimek wrote:

In D59746#1440756, @hintonda wrote:

A better alternative would have been to add a cl::aliasopt for '-h' in llvm's CommandLineParser when '-help' was first added. However, that's no longer possible since some llvm based tools already use '-h' for other purposes.

Is that intentional? Can you point at samples?

A quick grep found these -- there could be more.

llvm-opt-report adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-objdump adds -h as an alias for --section-headers.
dsymutil adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-readobj adds -h as an alias for --file-headers.
llvm-dwarfdump adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-mt rolls its own via llvm-tblgen.

So, the only ones I found that aren't essentially aliases for help are in llvm-objdump and llvm-readobj.

[klimek]

In D59746#1458424, @hintonda wrote:

In D59746#1458086, @klimek wrote:

In D59746#1440756, @hintonda wrote:

A better alternative would have been to add a cl::aliasopt for '-h' in llvm's CommandLineParser when '-help' was first added. However, that's no longer possible since some llvm based tools already use '-h' for other purposes.

Is that intentional? Can you point at samples?

A quick grep found these -- there could be more.

llvm-opt-report adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-objdump adds -h as an alias for --section-headers.
dsymutil adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-readobj adds -h as an alias for --file-headers.
llvm-dwarfdump adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-mt rolls its own via llvm-tblgen.

So, the only ones I found that aren't essentially aliases for help are in llvm-objdump and llvm-readobj.

If we make it an alias by default, can somebody overwrite that?

[hintonda]

In D59746#1458432, @klimek wrote:

In D59746#1458424, @hintonda wrote:

In D59746#1458086, @klimek wrote:

In D59746#1440756, @hintonda wrote:

A better alternative would have been to add a cl::aliasopt for '-h' in llvm's CommandLineParser when '-help' was first added. However, that's no longer possible since some llvm based tools already use '-h' for other purposes.

Is that intentional? Can you point at samples?

A quick grep found these -- there could be more.

llvm-opt-report adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-objdump adds -h as an alias for --section-headers.
dsymutil adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-readobj adds -h as an alias for --file-headers.
llvm-dwarfdump adds -h for help and handles it after ParseCommandLineOptions returns.
llvm-mt rolls its own via llvm-tblgen.

So, the only ones I found that aren't essentially aliases for help are in llvm-objdump and llvm-readobj.

If we make it an alias by default, can somebody overwrite that?

Unfortunately, that produces a runtime error:

lan1:/Users/dhinton/projects/llvm_project/monorepo/build/Debug $ bin/llvm-objdump -h
: CommandLine Error: Option 'h' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

The operative lines:

llvm/tools/llvm-objdump/llvm-objdump.cpp:187:static cl::alias SectionHeadersShorter("h",
llvm/lib/Support/CommandLine.cpp:2149:static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp));

[hintonda]

In D59746#1458461, @hintonda wrote:

In D59746#1458432, @klimek wrote:

If we make it an alias by default, can somebody overwrite that?

Unfortunately, that produces a runtime error:

lan1:/Users/dhinton/projects/llvm_project/monorepo/build/Debug $ bin/llvm-objdump -h
: CommandLine Error: Option 'h' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

The operative lines:

llvm/tools/llvm-objdump/llvm-objdump.cpp:187:static cl::alias SectionHeadersShorter("h",
llvm/lib/Support/CommandLine.cpp:2149:static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp));

The other problem is that these are statics, so you can't count on the order, i.e., did the user overwrite get processed before or after the one in CommandLine.cpp?

[klimek]

In D59746#1458539, @hintonda wrote:

In D59746#1458461, @hintonda wrote:

In D59746#1458432, @klimek wrote:

If we make it an alias by default, can somebody overwrite that?

Unfortunately, that produces a runtime error:

lan1:/Users/dhinton/projects/llvm_project/monorepo/build/Debug $ bin/llvm-objdump -h
: CommandLine Error: Option 'h' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

The operative lines:

llvm/tools/llvm-objdump/llvm-objdump.cpp:187:static cl::alias SectionHeadersShorter("h",
llvm/lib/Support/CommandLine.cpp:2149:static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp));

The other problem is that these are statics, so you can't count on the order, i.e., did the user overwrite get processed before or after the one in CommandLine.cpp?

If we can extend cl::alias to support this, we could give it a priority and take the highest prio :)

[hintonda]

In D59746#1459672, @klimek wrote:

In D59746#1458539, @hintonda wrote:

In D59746#1458461, @hintonda wrote:

In D59746#1458432, @klimek wrote:

If we make it an alias by default, can somebody overwrite that?

Unfortunately, that produces a runtime error:

lan1:/Users/dhinton/projects/llvm_project/monorepo/build/Debug $ bin/llvm-objdump -h
: CommandLine Error: Option 'h' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

The operative lines:

llvm/tools/llvm-objdump/llvm-objdump.cpp:187:static cl::alias SectionHeadersShorter("h",
llvm/lib/Support/CommandLine.cpp:2149:static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp));

The other problem is that these are statics, so you can't count on the order, i.e., did the user overwrite get processed before or after the one in CommandLine.cpp?

If we can extend cl::alias to support this, we could give it a priority and take the highest prio :)

Okay, I'll give it that old college try, and see if I can come up with something not too kludgy. ;-)

[hintonda]

In D59746#1459826, @hintonda wrote:

In D59746#1459672, @klimek wrote:

In D59746#1458539, @hintonda wrote:

In D59746#1458461, @hintonda wrote:

In D59746#1458432, @klimek wrote:

If we make it an alias by default, can somebody overwrite that?

Unfortunately, that produces a runtime error:

lan1:/Users/dhinton/projects/llvm_project/monorepo/build/Debug $ bin/llvm-objdump -h
: CommandLine Error: Option 'h' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

The operative lines:

llvm/tools/llvm-objdump/llvm-objdump.cpp:187:static cl::alias SectionHeadersShorter("h",
llvm/lib/Support/CommandLine.cpp:2149:static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp));

The other problem is that these are statics, so you can't count on the order, i.e., did the user overwrite get processed before or after the one in CommandLine.cpp?

If we can extend cl::alias to support this, we could give it a priority and take the highest prio :)

Okay, I'll give it that old college try, and see if I can come up with something not too kludgy. ;-)

Btw, do you just want default aliases, or default options in general?

[hintonda]

In D59746#1459906, @hintonda wrote:

In D59746#1459826, @hintonda wrote:

In D59746#1459672, @klimek wrote:

If we can extend cl::alias to support this, we could give it a priority and take the highest prio :)

Okay, I'll give it that old college try, and see if I can come up with something not too kludgy. ;-)

Btw, do you just want default aliases, or default options in general?

I hope you don't mind, but I've got a few more design questions:

• should the default api be public, usable by Clang Tooling, or just usable within CommandLine.cpp?
• which options should be hard-coded, i.e., status quo, and which should be defaulted.
• should we provide some sort of diagnostic to user to alert them that they have overwritten a defaulted options -- note this has to happen at runtime. Guess it could be a help option, a la hidden-help, that shows status of each option. I actually like the idea of option origin in general.

[hintonda]

Have a working prototype for aliases, but underneath, an option is an option, so should be able to support both without any trouble. Will upload as soon as I clean it up and add tests, etc...

[jhenderson]

Just chiming in from a LLVM binutils developer perspective. Some of the binutils are missing -h as an alias, when they really should have it for compatibility (specifically I checked llvm-nm and llvm-symbolizer). As a result, a solution that auto-adds -h as an alias would be good, as long as we have the ability to override it somehow. I wouldn't mind having logic in llvm-objdump/llvm-readobj to explicitly override the short alias if it is required.

[hintonda]

• Add DefaultOption logic.

Still needs tests, but wanted to get early feedback on basic approach.

[hintonda]

llvm/lib/Support/CommandLine.cpp

1211

Looks like this is a bug in the way sub commands are handled, but I'd like to get feedback on how it *should* work.

The problem is that if an option is added with cl::sub(*AllSubCommands) it gets added to all registered subcommands, including TopLevelSubCommand. However, TopLevelSubCommand isn't included in Option::Subs, so I have to update/remove via two commands, one at the parser level for the ChosenSubCommand, which happens to be TopLevelSubCommand in this case, and another for the Option itself, which doesn't have TopLevelSubCommand in it's subs.

Should CommandLineParser::addOption specifically exclude TopLevelSubCommand when it add subs to an Option? That seems like a bug to me, but I'm not sure I grok the reason it was excluded.

[hintonda]

• Fix bug in updateArgStr() where it didn't handle isInAllSubCommands() correctly, and refactored code based on how SubCommands work.

[jhenderson]

I've not looked at the implementation in depth, but cl::DefaultOption seems like a nice way of handling this. Please make sure that there is testing in llvm-readobj and llvm-objdump that test their own short alias interpretation somewhere though.

[hintonda]

• Delay actually adding default options until ParseCommandLineOptions which simplifies handling and makes it easy to only add them to the correct SubCommand.
  
  Add simple tests.

[hintonda]

llvm/lib/Support/CommandLine.cpp

288–294

Will move this bug fix to its own patch and add test.

[hintonda]

In D59746#1462352, @jhenderson wrote:

I've not looked at the implementation in depth, but cl::DefaultOption seems like a nice way of handling this. Please make sure that there is testing in llvm-readobj and llvm-objdump that test their own short alias interpretation somewhere though.

While I'm still working on unittests, I have added a few tests that should cover this. Please let me know if you have any concerns.

[hintonda]

• Add unittest.

[hintonda]

Enhance Option::reset to reset the default value and remove the option
if it's a cl::DefaultOption.

Also, make sure removeOption only removes an option if both the name
and the Option matches, not just the name -- different Options with
the same name in different SubCommands have always been possible, but
are more common with DefaultOptions.

[hintonda]

@klimek, this patch is now ready for review. Thanks...

[klimek]

llvm/lib/Support/CommandLine.cpp

101

A comment explaining what this contains and how it'll be used would help.

155

This is used multiple times, add isDefault() to Option?

199

I'd delete this comment, I don't think it helps.

1201

Same here, this comment doesn't say anything non-obvious.

[hintonda]

• Fix comments and add isDefaultOption per review comments.

[klimek]

lg

[hintonda]

In D59746#1465445, @klimek wrote:

lg

Thanks again for the help and the suggestion.

[hintonda]

Reopen to track fix after buildbot failure and revert -- r358414.

http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20190415/644037.html

[hintonda]

• Original patch, r358337, that was reverted.
• Make sure to clear DefaultOptions on reset.

[hintonda]

• Add new test back.

clang/lib/Tooling/CommonOptionsParser.cpp

for (CompileCommand &Command : Commands)
     for (const auto &Adjuster : Adjusters)
       Command.CommandLine = Adjuster(Command.CommandLine, Command.Filename);
   return Commands;
 }
 
 llvm::Error CommonOptionsParser::init(
     int &argc, const char **argv, cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {
-  static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
-                            cl::sub(*cl::AllSubCommands));
 
   static cl::opt<std::string> BuildPath("p", cl::desc("Build path"),
                                         cl::Optional, cl::cat(Category),
                                         cl::sub(*cl::AllSubCommands));
 
   static cl::list<std::string> SourcePaths(
       cl::Positional, cl::desc("<source0> [... <sourceN>]"), OccurrencesFlag,
       cl::cat(Category), cl::sub(*cl::AllSubCommands));

llvm/docs/CommandLine.rst

 output for the "``-help``" option.  In this case, we get a line that looks like
 this:
 
 ::
 
   USAGE: compiler [options]
 
   OPTIONS:
+    -h                - Alias for -help
     -help             - display available options (-help-hidden for more)
     -o <filename>     - Specify output filename
 
 Because we specified that the command line option should parse using the
 ``string`` data type, the variable declared is automatically usable as a real
 string in all contexts that a normal C++ string object may be used.  For
 example:
 

 behaviour of the library, on a per-option basis.  By adding one of the
 declarations above, the ``-help`` option synopsis is now extended to:
 
 ::
 
   USAGE: compiler [options] <input file>
 
   OPTIONS:
+    -h                - Alias for -help
     -help             - display available options (-help-hidden for more)
     -o <filename>     - Specify output filename
 
 ... indicating that an input filename is expected.
 
 Boolean Arguments
 -----------------
 

 .. _cl::Sink:
 
 * The **cl::Sink** modifier is used to handle unknown options. If there is at
   least one option with ``cl::Sink`` modifier specified, the parser passes
   unrecognized option strings to it as values instead of signaling an error. As
   with ``cl::CommaSeparated``, this modifier only makes sense with a `cl::list`_
   option.
 
+.. _cl::DefaultOption:
+
+* The **cl::DefaultOption** modifier is used to specify that the option is a
+  default that can be overridden by application specific parsers. For example,
+  the ``-help`` alias, ``-h``, is registered this way, so it can be overridden
+  by applications that need to use the ``-h`` option for another purpose,
+  either as a regular option or an alias for another option.
+
 .. _response files:
 
 Response files
 ^^^^^^^^^^^^^^
 
 Some systems, such as certain variants of Microsoft Windows and some older
 Unices have a relatively low limit on command-line length. It is therefore
 customary to use the so-called 'response files' to circumvent this

llvm/include/llvm/Support/CommandLine.h

enum MiscFlags {             // Miscellaneous flags to adjust argument
   CommaSeparated = 0x01,     // Should this cl::list split between commas?
   PositionalEatsArgs = 0x02, // Should this positional cl::list eat -args?
   Sink = 0x04,               // Should this cl::list eat all unknown options?
 
   // Grouping - Can this option group with other options?
   // If this is enabled, multiple letter options are allowed to bunch together
   // with only a single hyphen for the whole group.  This allows emulation
   // of the behavior that ls uses for example: ls -la === ls -l -a
-  Grouping = 0x08
+  Grouping = 0x08,
+
+  // Default option
+  DefaultOption = 0x10
 };
 
 //===----------------------------------------------------------------------===//
 // Option Category class
 //
 class OptionCategory {
 private:
   StringRef const Name;
class Option {
   // Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
   // problems with signed enums in bitfields.
   unsigned Occurrences : 3; // enum NumOccurrencesFlag
   // not using the enum type for 'Value' because zero is an implementation
   // detail representing the non-value
   unsigned Value : 2;
   unsigned HiddenFlag : 2; // enum OptionHidden
   unsigned Formatting : 2; // enum FormattingFlags
-  unsigned Misc : 4;
+  unsigned Misc : 5;
   unsigned Position = 0;       // Position of last occurrence of the option
   unsigned AdditionalVals = 0; // Greater than 0 for multi-valued option.
 
 public:
   StringRef ArgStr;   // The argument string itself (ex: "help", "o")
   StringRef HelpStr;  // The descriptive text message for -help
   StringRef ValueStr; // String describing what the value of this option is
   OptionCategory *Category; // The Category this option belongs to
public:
   inline unsigned getMiscFlags() const { return Misc; }
   inline unsigned getPosition() const { return Position; }
   inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
 
   // hasArgStr - Return true if the argstr != ""
   bool hasArgStr() const { return !ArgStr.empty(); }
   bool isPositional() const { return getFormattingFlag() == cl::Positional; }
   bool isSink() const { return getMiscFlags() & cl::Sink; }
+  bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
 
   bool isConsumeAfter() const {
     return getNumOccurrencesFlag() == cl::ConsumeAfter;
   }
 
   bool isInAllSubCommands() const {
     return any_of(Subs, [](const SubCommand *SC) {
       return SC == &*AllSubCommands;
public:
 
   // Prints option name followed by message.  Always returns true.
   bool error(const Twine &Message, StringRef ArgName = StringRef(), raw_ostream &Errs = llvm::errs());
   bool error(const Twine &Message, raw_ostream &Errs) {
     return error(Message, StringRef(), Errs);
   }
 
   inline int getNumOccurrences() const { return NumOccurrences; }
-  inline void reset() { NumOccurrences = 0; }
+  void reset();
 };
 
 //===----------------------------------------------------------------------===//
 // Command line option modifiers that can be used to modify the behavior of
 // command line option parsers...
 //
 
 // desc - Modifier to set the description shown in the -help output...
ValueExpected getValueExpectedFlagDefault() const override {
     return AliasFor->getValueExpectedFlag();
   }
 
   void done() {
     if (!hasArgStr())
       error("cl::alias must have argument name specified!");
     if (!AliasFor)
       error("cl::alias must have an cl::aliasopt(option) specified!");
+    if (!Subs.empty())
+      error("cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!");
     Subs = AliasFor->Subs;
+    Category = AliasFor->Category;
     addArgument();
   }
 
 public:
   // Command line options should not be copyable
   alias(const alias &) = delete;
   alias &operator=(const alias &) = delete;
 

llvm/lib/Support/CommandLine.cpp

public:
   // Globals for name and overview of program.  Program name is not a string to
   // avoid static ctor/dtor issues.
   std::string ProgramName;
   StringRef ProgramOverview;
 
   // This collects additional help to be printed.
   std::vector<StringRef> MoreHelp;
 
+  // This collects Options added with the cl::DefaultOption flag. Since they can
+  // be overridden, they are not added to the appropriate SubCommands until
+  // ParseCommandLineOptions actually runs.
+  SmallVector<Option*, 4> DefaultOptions;
+
   // This collects the different option categories that have been registered.
   SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
 
   // This collects the different subcommands that have been registered.
   SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;
 
   CommandLineParser() : ActiveSubCommand(nullptr) {
     registerSubCommand(&*TopLevelSubCommand);
else {
       for (auto SC : Opt.Subs)
         addLiteralOption(Opt, SC, Name);
     }
   }
 
   void addOption(Option *O, SubCommand *SC) {
     bool HadErrors = false;
     if (O->hasArgStr()) {
+      // If it's a DefaultOption, check to make sure it isn't already there.
+      if (O->isDefaultOption() &&
+          SC->OptionsMap.find(O->ArgStr) != SC->OptionsMap.end())
+        return;
+
       // Add argument to the argument map!
       if (!SC->OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
         errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
                << "' registered more than once!\n";
         HadErrors = true;
       }
     }
 
if (SC == &*AllSubCommands) {
       for (const auto &Sub : RegisteredSubCommands) {
         if (SC == Sub)
           continue;
         addOption(O, Sub);
       }
     }
   }
 
-  void addOption(Option *O) {
+  void addOption(Option *O, bool ProcessDefaultOption = false) {
+    if (!ProcessDefaultOption && O->isDefaultOption()) {
+      DefaultOptions.push_back(O);
+      return;
+    }
+
     if (O->Subs.empty()) {
       addOption(O, &*TopLevelSubCommand);
     } else {
       for (auto SC : O->Subs)
         addOption(O, SC);
     }
   }
 
   void removeOption(Option *O, SubCommand *SC) {
     SmallVector<StringRef, 16> OptionNames;
     O->getExtraOptionNames(OptionNames);
     if (O->hasArgStr())
       OptionNames.push_back(O->ArgStr);
 
     SubCommand &Sub = *SC;
-    for (auto Name : OptionNames)
-      Sub.OptionsMap.erase(Name);
+    auto End = Sub.OptionsMap.end();
+    for (auto Name : OptionNames) {
+      auto I = Sub.OptionsMap.find(Name);
+      if (I != End && I->getValue() == O)
+        Sub.OptionsMap.erase(I);
+      }
 
     if (O->getFormattingFlag() == cl::Positional)
       for (auto Opt = Sub.PositionalOpts.begin();
            Opt != Sub.PositionalOpts.end(); ++Opt) {
         if (*Opt == O) {
           Sub.PositionalOpts.erase(Opt);
           break;
         }
void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) {
     }
     Sub.OptionsMap.erase(O->ArgStr);
   }
 
   void updateArgStr(Option *O, StringRef NewName) {
     if (O->Subs.empty())
       updateArgStr(O, NewName, &*TopLevelSubCommand);
     else {
+      if (O->isInAllSubCommands()) {
+        for (auto SC : RegisteredSubCommands)
+          updateArgStr(O, NewName, SC);
+      } else {
         for (auto SC : O->Subs)
           updateArgStr(O, NewName, SC);
       }
     }
+  }
 
   void printOptionValues();
 
   void registerCategory(OptionCategory *cat) {
     assert(count_if(RegisteredOptionCategories,
                     [cat](const OptionCategory *Category) {
              return cat->getName() == Category->getName();
            }) == 0 &&

 
 void Option::setArgStr(StringRef S) {
   if (FullyInitialized)
     GlobalParser->updateArgStr(this, S);
   assert((S.empty() || S[0] != '-') && "Option can't start with '-");
   ArgStr = S;
 }
 
+void Option::reset() {
+  NumOccurrences = 0;
+  setDefault();
+  if (isDefaultOption())
+    removeArgument();
+}
+
 // Initialise the general option category.
 OptionCategory llvm::cl::GeneralCategory("General options");
 
 void OptionCategory::registerCategory() {
   GlobalParser->registerCategory(this);
 }
 
 // A special subcommand representing no subcommand. It is particularly important
bool CommandLineParser::ParseCommandLineOptions(int argc,
   GlobalParser->ActiveSubCommand = ChosenSubCommand;
 
   assert(ChosenSubCommand);
   auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
   auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
   auto &SinkOpts = ChosenSubCommand->SinkOpts;
   auto &OptionsMap = ChosenSubCommand->OptionsMap;
 
+  for (auto O: DefaultOptions) {
+    addOption(O, true);
+  }
+
   if (ConsumeAfterOpt) {
     assert(PositionalOpts.size() > 0 &&
            "Cannot specify cl::ConsumeAfter without a positional argument!");
   }
   if (!PositionalOpts.empty()) {
 
     // Calculate how many positional values are _required_.
     bool UnboundedFound = false;
     for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
       Option *Opt = PositionalOpts[i];
       if (RequiresValue(Opt))
         ++NumPositionalRequired;
       else if (ConsumeAfterOpt) {
         // ConsumeAfter cannot be combined with "optional" positional options
         // unless there is only one positional argument...

 // Define uncategorized/categorized help printers. These printers change their
 // behaviour at runtime depending on whether one or more Option categories have
 // been declared.
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HOp("help", cl::desc("Display available options (-help-hidden for more)"),
         cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
+static cl::alias HOpA("h", cl::desc("Alias for -help"), cl::aliasopt(HOp),
+                      cl::DefaultOption);
+
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HHOp("help-hidden", cl::desc("Display all available options"),
          cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
          cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<bool> PrintOptions(
     "print-options",
     cl::desc("Print non-default options after command line parsing"),

llvm/test/Support/check-default-options.txt

+# RUN: llvm-objdump -help-hidden %t | FileCheck --check-prefix=CHECK-OBJDUMP %s
+# RUN: llvm-readobj -help-hidden %t | FileCheck --check-prefix=CHECK-READOBJ %s
+# RUN: llvm-tblgen -help-hidden %t | FileCheck --check-prefix=CHECK-TBLGEN %s
+# RUN: llvm-opt-report -help-hidden %t | FileCheck --check-prefix=CHECK-OPT-RPT %s
+# RUN: llvm-dwarfdump -help-hidden %t | FileCheck --check-prefix=CHECK-DWARF %s
+# RUN: llvm-dwarfdump -h %t | FileCheck --check-prefix=CHECK-DWARF-H %s
+
+
+# CHECK-OBJDUMP: -h  - Alias for --section-headers
+# CHECK-READOBJ: -h  - Alias for --file-headers
+# CHECK-TBLGEN:  -h  - Alias for -help
+# CHECK-OPT-RPT: -h  - Alias for -help
+# CHECK-DWARF:   -h  - Alias for -help
+
+# llvm-dwarfdump declares `-h` option and prints special help in that case,
+# which is weird, but makes for a good test, i.e., shows the default `-h`
+# wasn't used.
+# CHECK-DWARF-H-NOT: -help-list  - Display list of available options (-help-list-hidden for more)

llvm/tools/llvm-opt-report/OptReport.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <map>
 #include <set>
 
 using namespace llvm;
 using namespace llvm::yaml;
 
-static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
-
 // Mark all our options with this category, everything else (except for -version
 // and -help) will be hidden.
 static cl::OptionCategory
     OptReportCategory("llvm-opt-report options");
 
 static cl::opt<std::string>
   InputFileName(cl::Positional, cl::desc("<input>"), cl::init("-"),
                 cl::cat(OptReportCategory));
int main(int argc, const char **argv) {
   InitLLVM X(argc, argv);
 
   cl::HideUnrelatedOptions(OptReportCategory);
   cl::ParseCommandLineOptions(
       argc, argv,
       "A tool to generate an optimization report from YAML optimization"
       " record files.\n");
 
-  if (Help) {
-    cl::PrintHelpMessage();
-    return 0;
-  }
-
   LocationInfoTy LocationInfo;
   if (!readLocationInfo(LocationInfo))
     return 1;
   if (!writeReport(LocationInfo))
     return 1;
 
   return 0;
 }

llvm/unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, GetRegisteredSubcommands) {
   EXPECT_FALSE(Opt2);
   for (auto *S : cl::getRegisteredSubcommands()) {
     if (*S) {
       EXPECT_EQ("sc2", S->getName());
     }
   }
 }
 
+TEST(CommandLineTest, DefaultOptions) {
+  cl::ResetCommandLineParser();
+
+  StackOption<std::string> Bar("bar", cl::sub(*cl::AllSubCommands),
+                               cl::DefaultOption);
+  StackOption<std::string, cl::alias> Bar_Alias(
+      "b", cl::desc("Alias for -bar"), cl::aliasopt(Bar), cl::DefaultOption);
+
+  StackOption<bool> Foo("foo", cl::init(false), cl::sub(*cl::AllSubCommands),
+                        cl::DefaultOption);
+  StackOption<bool, cl::alias> Foo_Alias("f", cl::desc("Alias for -foo"),
+                                         cl::aliasopt(Foo), cl::DefaultOption);
+
+  StackSubCommand SC1("sc1", "First Subcommand");
+  // Override "-b" and change type in sc1 SubCommand.
+  StackOption<bool> SC1_B("b", cl::sub(SC1), cl::init(false));
+  StackSubCommand SC2("sc2", "Second subcommand");
+  // Override "-foo" and change type in sc2 SubCommand.  Note that this does not
+  // affect "-f" alias, which continues to work correctly.
+  StackOption<std::string> SC2_Foo("foo", cl::sub(SC2));
+
+  const char *args0[] = {"prog", "-b", "args0 bar string", "-f"};
+  EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args0) / sizeof(char *), args0,
+                                          StringRef(), &llvm::nulls()));
+  EXPECT_TRUE(Bar == "args0 bar string");
+  EXPECT_TRUE(Foo);
+  EXPECT_FALSE(SC1_B);
+  EXPECT_TRUE(SC2_Foo.empty());
+
+  cl::ResetAllOptionOccurrences();
+
+  const char *args1[] = {"prog", "sc1", "-b", "-bar", "args1 bar string", "-f"};
+  EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args1) / sizeof(char *), args1,
+                                          StringRef(), &llvm::nulls()));
+  EXPECT_TRUE(Bar == "args1 bar string");
+  EXPECT_TRUE(Foo);
+  EXPECT_TRUE(SC1_B);
+  EXPECT_TRUE(SC2_Foo.empty());
+  for (auto *S : cl::getRegisteredSubcommands()) {
+    if (*S) {
+      EXPECT_EQ("sc1", S->getName());
+    }
+  }
+
+  cl::ResetAllOptionOccurrences();
+
+  const char *args2[] = {"prog", "sc2", "-b", "args2 bar string",
+                         "-f", "-foo", "foo string"};
+  EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args2) / sizeof(char *), args2,
+                                          StringRef(), &llvm::nulls()));
+  EXPECT_TRUE(Bar == "args2 bar string");
+  EXPECT_TRUE(Foo);
+  EXPECT_FALSE(SC1_B);
+  EXPECT_TRUE(SC2_Foo == "foo string");
+  for (auto *S : cl::getRegisteredSubcommands()) {
+    if (*S) {
+      EXPECT_EQ("sc2", S->getName());
+    }
+  }
+}
+
 TEST(CommandLineTest, ArgumentLimit) {
   std::string args(32 * 4096, 'a');
   EXPECT_FALSE(llvm::sys::commandLineFitsWithinSystemLimits("cl", args.data()));
 }
 
 TEST(CommandLineTest, ResponseFileWindows) {
   if (!Triple(sys::getProcessTriple()).isOSWindows())
     return;