[CommandLine] Don't print empty sentinel values from EnumValN lists in help text

[jhenderson]

Summary

In order to make an option value truly optional, both the ValueOptional attribute and an empty-named value are required. Prior to this change, this empty-named value appears in
the command-line help text:

-some-option - some help text
  =v1        - description 1
  =v2        - description 2
  =          -

This change improves the help text for these sort of options in a number of ways:

1. ValueOptional options with an empty-named value now print their help text twice: both without and then with '=<value>' after the name. The latter version then lists the allowed values after it.
2. Empty-named values with no help text in ValueOptional options are not listed in the permitted values.

-some-option         - some help text
-some-option=<value> - some help text
  =v1                - description 1
  =v2                - description 2

3. Otherwise empty-named options are printed as =<empty> rather than simply '='.
4. Option values without help text do not have the '-' separator printed.

-some-option=<value> - some help text
  =v1                - description 1
  =v2
  =<empty>           - description

It also tweaks the llvm-symbolizer -functions help text to not print a trailing ':' as that looks bad combined with 1) above.

[thopre]

Do such sentinel trigger if not passing the equal sign (ie. when using only "-mhvx" in the example you quote) or only with equal sign without a value (one has to use "-mhvx=" to select the option)?

If the former I think this change is fine. I would also suggest adding an early continue when only the description is empty on line 1683 to avoid the empty '-'.

But if the latter (one has to do "-mhvx=" to select the option) I'm not sure hiding the option is right since it is a value (albeit empty) people can use.

lib/Support/CommandLine.cpp

1683 ↗

(On Diff #182812)

Add early continue here as well when only description is empty?

[jhenderson]

In D57030#1365762, @thopre wrote:

Do such sentinel trigger if not passing the equal sign (ie. when using only "-mhvx" in the example you quote) or only with equal sign without a value (one has to use "-mhvx=" to select the option)?

If the former I think this change is fine. I would also suggest adding an early continue when only the description is empty on line 1683 to avoid the empty '-'.

But if the latter (one has to do "-mhvx=" to select the option) I'm not sure hiding the option is right since it is a value (albeit empty) people can use.

Assuming ValueOptional is specified, then yes, you don't need the equal sign. I've written up a table below of different input options versus their behaviour to clarify things:

Code	--option	--option=	--option foo	--option=foo
default, no sentinel	not allowed	not allowed	allowed	allowed
default, sentinel	not allowed	allowed	allowed	allowed
ValueOptional, no sentinel	not allowed	not allowed	not allowed	allowed
ValueOptional, sentinel	allowed	allowed	not allowed	allowed

lib/Support/CommandLine.cpp

1683 ↗

(On Diff #182812)

Seems reasonable to me, although the '\n' is required still. To avoid repeating it, I'll write it as:

if (!getDescription(i).empty())
  outs().indent(NumSpaces) << " -   " << getDescription(i);
outs() << '\n';

[jhenderson]

Don't print empty description for option value with no description.

[thopre]

In D57030#1365979, @jhenderson wrote:

In D57030#1365762, @thopre wrote:

Do such sentinel trigger if not passing the equal sign (ie. when using only "-mhvx" in the example you quote) or only with equal sign without a value (one has to use "-mhvx=" to select the option)?

If the former I think this change is fine. I would also suggest adding an early continue when only the description is empty on line 1683 to avoid the empty '-'.

But if the latter (one has to do "-mhvx=" to select the option) I'm not sure hiding the option is right since it is a value (albeit empty) people can use.

Assuming ValueOptional is specified, then yes, you don't need the equal sign. I've written up a table below of different input options versus their behaviour to clarify things:

Code	--option	--option=	--option foo	--option=foo
default, no sentinel	not allowed	not allowed	allowed	allowed
default, sentinel	not allowed	allowed	allowed	allowed
ValueOptional, no sentinel	not allowed	not allowed	not allowed	allowed
ValueOptional, sentinel	allowed	allowed	not allowed	allowed

Thanks for the explanation. In that case I'd like to differentiate between the optional and non optional case.

1. For optional omitting the line is probably fine, or perhaps put a [default] instead of empty equal sign.
2. To handle the non optional case I think we should introduce single quotes after the equal sign to indicate that this is not an error but an empty value, ie. =''. Perhaps also put quote around other values for consistency.

Does that make sense?

[jhenderson]

In D57030#1366088, @thopre wrote:

Thanks for the explanation. In that case I'd like to differentiate between the optional and non optional case.

1. For optional omitting the line is probably fine, or perhaps put a [default] instead of empty equal sign.
2. To handle the non optional case I think we should introduce single quotes after the equal sign to indicate that this is not an error but an empty value, ie. =''. Perhaps also put quote around other values for consistency.

Does that make sense?

I'm afraid I'm not quite sure what you mean by the "optional and non optional case". Do you mean when ValueOptional is and is not used?

[thopre]

In D57030#1366269, @jhenderson wrote:

In D57030#1366088, @thopre wrote:

Thanks for the explanation. In that case I'd like to differentiate between the optional and non optional case.

1. For optional omitting the line is probably fine, or perhaps put a [default] instead of empty equal sign.
2. To handle the non optional case I think we should introduce single quotes after the equal sign to indicate that this is not an error but an empty value, ie. =''. Perhaps also put quote around other values for consistency.

Does that make sense?

I'm afraid I'm not quite sure what you mean by the "optional and non optional case". Do you mean when ValueOptional is and is not used?

Yes my bad, that is what I meant: 1) is when ValueOptional is used, 2) is when it isn't.

Best regards,

Thomas

[ruiu]

Ideally I believe we should print out something like this for an option that takes an optional argument:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
   =v60                                           -   Build for HVX v60
   =v62                                           -   Build for HVX v62
   =v65                                           -   Build for HVX v65
   =v66                                           -   Build for HVX v66

Do you think that's doable?

[thopre]

In D57030#1367059, @ruiu wrote:

Ideally I believe we should print out something like this for an option that takes an optional argument:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
   =v60                                           -   Build for HVX v60
   =v62                                           -   Build for HVX v62
   =v65                                           -   Build for HVX v65
   =v66                                           -   Build for HVX v66

Do you think that's doable?

+1, that is much clearer. Perhaps even:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx='<value>'                            - Enable Hexagon Vector eXtensions
   ='v60'                                           -   Build for HVX v60
   ='v62'                                           -   Build for HVX v62
   ='v65'                                           -   Build for HVX v65
   ='v66'                                           -   Build for HVX v66

To be able to list ='' for sentinel value which are not ValueOptional.

[jhenderson]

Sounds reasonable to try it at least. I'll take a look.

[jhenderson]

In D57030#1367399, @thopre wrote:

To be able to list ='' for sentinel value which are not ValueOptional.

Thinking about it, I have a slight concern that adding the quotes could cause confusion, because theoretically a valid value could iteslf have quotes in, so this makes the help text ambiguous: does the value include the quotes either end or not? How about =<empty> for the "sentinel" value?

[jhenderson]

I've tweaked the output as discussed. For a ValueOptional with sentinel value, it prints something like the following:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
  =v60                                           -   Build for HVX v60
  =v62                                           -   Build for HVX v62
  =v65                                           -   Build for HVX v65
  =v66                                           -   Build for HVX v66

Without a sentinel value it prints:

-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
  =v60                                           -   Build for HVX v60
  =v62                                           -   Build for HVX v62
  =v65                                           -   Build for HVX v65
  =v66                                           -   Build for HVX v66

For ValueRequired with an empty string value it prints:

-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
  =v60                                           -   Build for HVX v60
  =v62                                           -   Build for HVX v62
  =v65                                           -   Build for HVX v65
  =v66                                           -   Build for HVX v66
  =<empty>

The latter also demonstrates what happens if the description is empty.

[thopre]

I like this new version very much. I agree, <empty> is less likely to be confusing. One last nit: why do you check for the description being empty when deciding to skip an empty value for a ValueOptional option in the second block but not in the first block? Any reason for the inconsistency?

[jhenderson]

In D57030#1367818, @thopre wrote:

I like this new version very much. I agree, <empty> is less likely to be confusing. One last nit: why do you check for the description being empty when deciding to skip an empty value for a ValueOptional option in the second block but not in the first block? Any reason for the inconsistency?

It wasn't intentional, but I think it is okay (although I could be persuaded to do something different). As things stand, an empty string with help text would produce something like this for a ValueOptional option:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
  =v60                                           -   Build for HVX v60
  =v62                                           -   Build for HVX v62
  =v65                                           -   Build for HVX v65
  =v66                                           -   Build for HVX v66
  =<empty>                                       -   Same as v66

We could instead suppress the =<empty> line always (even if it has a description), or we could always print the =<empty> line regardless of whether it has a description or not, I don't mind.

[thopre]

In D57030#1367857, @jhenderson wrote:

In D57030#1367818, @thopre wrote:

I like this new version very much. I agree, <empty> is less likely to be confusing. One last nit: why do you check for the description being empty when deciding to skip an empty value for a ValueOptional option in the second block but not in the first block? Any reason for the inconsistency?

It wasn't intentional, but I think it is okay (although I could be persuaded to do something different). As things stand, an empty string with help text would produce something like this for a ValueOptional option:

-mhvx                                            - Enable Hexagon Vector eXtensions
-mhvx=<value>                                    - Enable Hexagon Vector eXtensions
  =v60                                           -   Build for HVX v60
  =v62                                           -   Build for HVX v62
  =v65                                           -   Build for HVX v65
  =v66                                           -   Build for HVX v66
  =<empty>                                       -   Same as v66

We could instead suppress the =<empty> line always (even if it has a description), or we could always print the =<empty> line regardless of whether it has a description or not, I don't mind.

Fair enough, that's quite a nice output. LGTM, thanks! Will approve in one day if nobody objects.

[ruiu]

I found this file: llvm/unittests/Support/CommandLineTest.cpp

Maybe you can add a test for the new functionality to that file.

[jhenderson]

In D57030#1367916, @ruiu wrote:

I found this file: llvm/unittests/Support/CommandLineTest.cpp

Maybe you can add a test for the new functionality to that file.

That's where I would test this, yes, but the function is all about printing to outs(), and I don't know of a way using LLVM's tools to test that. Can you (or anybody else) suggest anything?

I guess I could just put a test in "test/Other" which runs a tools with --help that prints the various forms available (although I don't think the "=<empty>" path is used anywhere currently).

[jhenderson]

Remove colon from help text, which now won't have anything listed after it. Without this change, the following would have been the output of llvm-symbolizer --help with this patch:

-functions                        - Print function name for a given address:
-functions=<value>                - Print function name for a given address:
  =none                           -   omit function name
  =short                          -   print short function name
  =linkage                        -   print function linkage name (default)

I checked and couldn't find anywhere else that would be impacted in this way.

[thopre]

In D57030#1369239, @jhenderson wrote:

In D57030#1367916, @ruiu wrote:

I found this file: llvm/unittests/Support/CommandLineTest.cpp

Maybe you can add a test for the new functionality to that file.

That's where I would test this, yes, but the function is all about printing to outs(), and I don't know of a way using LLVM's tools to test that. Can you (or anybody else) suggest anything?

I guess I could just put a test in "test/Other" which runs a tools with --help that prints the various forms available (although I don't think the "=<empty>" path is used anywhere currently).

Can't you use something like dup2 (but more portable across platforms) to redirect the output to a file, read that file and check its content?

[jhenderson]

Add unit tests.

Windows appears to accept dup et al, so I'm using that for now.

[thopre]

unittests/Support/CommandLineTest.cpp

860–861 ↗

(On Diff #184059)

Why not make them private with getters? Did you deem it over-engineering?

917–918 ↗

(On Diff #184059)

I understand the use of variable to avoid duplication but it makes it harder to see that we are testing for correct alignment. Could you choose variables with the right length to have the same alignment as the output text such that we can see the alignment by just looking at the text?

929–930 ↗

(On Diff #184059)

I think it's better to go to next line for every \n, I'd suggest also keeping the \n at end of line to make the reference string as close as the output. Likewise for other tests below and above.

[jhenderson]

unittests/Support/CommandLineTest.cpp

860–861 ↗

(On Diff #184059)

Yes, essentially. If you prefer me to add getters, I don't mind.

917–918 ↗

(On Diff #184059)

Sounds good to me. I'll do that.

929–930 ↗

(On Diff #184059)

That's what I wanted to do, but this is how clang-format lines it up. I'm happy to not run clang-format on this section, if you are.

[thopre]

unittests/Support/CommandLineTest.cpp

860–861 ↗

(On Diff #184059)

I'm thinking more in terms of readability as someone reading understands from getter without setter that it's a constant value. I would have prefer a simple const though, and the testcase is small enough and obvious enough that it's not much of a problem. Maybe you made the good call, let's leave it as is.

929–930 ↗

(On Diff #184059)

I'm quite new to the community so not sure how is it viewed to ignore clang-format. In my opinion formatting is to improve readability by consistency, in this case having things as close as possible to the output is more readable so I'd be in favour of ignoring clang-format just for that bit yes.

[jhenderson]

Improve test formatting, by overriding clang-format.

unittests/Support/CommandLineTest.cpp

929–930 ↗

(On Diff #184059)

I'm okay with not using clang-format here, personally. I agree with your assessment that formatting the code via clang-format makes it worse.

[thopre]

Splendid, thanks for addressing all my remarks and thanks ruiu for the excellent output formatting suggestion. LGTM.

[mstorsjo]

This broke the output of llvm-nm --help, which now loops (near) infinitely for me (both built with GCC on Ubuntu 16.04 and with Apple Clang on macOS). It's surprising that this doesn't seem to show up for others, as this is actually tested by test/tools/llvm-nm/libtool-response-file.test.

[mstorsjo]

In D57030#1380091, @mstorsjo wrote:

This broke the output of llvm-nm --help, which now loops (near) infinitely for me (both built with GCC on Ubuntu 16.04 and with Apple Clang on macOS). It's surprising that this doesn't seem to show up for others, as this is actually tested by test/tools/llvm-nm/libtool-response-file.test.

This only seems to be happening if the AArch64 target is enabled. In llvm-nm --help, the output is broken after -aarch64-neon-syntax=<value>, after which it just feeds an infinite stream of blank spaces.

[jhenderson]

In D57030#1380259, @mstorsjo wrote:

In D57030#1380091, @mstorsjo wrote:

This broke the output of llvm-nm --help, which now loops (near) infinitely for me (both built with GCC on Ubuntu 16.04 and with Apple Clang on macOS). It's surprising that this doesn't seem to show up for others, as this is actually tested by test/tools/llvm-nm/libtool-response-file.test.

This only seems to be happening if the AArch64 target is enabled. In llvm-nm --help, the output is broken after -aarch64-neon-syntax=<value>, after which it just feeds an infinite stream of blank spaces.

How strange. I'm pretty sure I have that target enabled locally. I'll try digging into it, and revert if it's not immediately obvious to allow for more investigation. For the record, I built and ran on both GCC 4.8.2 on Ubuntu 14.04 and Visual Studio 2015 on Windows.

[jhenderson]

Looks like a build bot picked up the same failure: http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/15346/

I'm staring at the code and cannot for the life of me see how the change could have caused this. Unfortunately, the test passes for me with current trunk (I just double-checked). @mstorsjo, since you are seeing it, would you mind debugging to identify where this goes wrong?

[jhenderson]

Reverted in rL352848.

[jhenderson]

I've been able to reproduce the failure by extending the length of the switch by a large amount. I think, though not yet confirmed, that the problem is that this patch didn't adjust the apparent option width due to adding "=<value>". You may be seeing it because you are building without the Hexagon target? That causes the -aarch64-neon-syntax=<value> line to be the longest arg string, and greater than the GlobalWidth, I believe, causing an underflow somewhere in the adjusted code.

I'll look at fixing that.

[mstorsjo]

In D57030#1380373, @jhenderson wrote:

I've been able to reproduce the failure by extending the length of the switch by a large amount. I think, though not yet confirmed, that the problem is that this patch didn't adjust the apparent option width due to adding "=<value>". You may be seeing it because you are building without the Hexagon target? That causes the -aarch64-neon-syntax=<value> line to be the longest arg string, and greater than the GlobalWidth, I believe, causing an underflow somewhere in the adjusted code.

Yes, that's correct, I'm building with ARM+AArch64+X86 only (and could also reproduce it in a build with AArch64 only).

I'll look at fixing that.

Great, thanks!

[jhenderson]

Fix getOptionWidth function for new behaviour, add some asserts for protection, add new unit tests for getOptionWidth, and pull out some of the brittle constants and strings into a single set of static variables.

[jhenderson]

Hi, could somebody take a look at the latest update? I've fixed the problem exposed, and tried to make the existing code a little less brittle and therefore less likely to run into the same issue in the future.

[thopre]

lib/Support/CommandLine.cpp

1662–1663 ↗

(On Diff #184741)

I wonder if a small inline function for this would make sense. BTW, do you know why the width is not computed from the return value of getOptionInfo?

unittests/Support/CommandLineTest.cpp

1023 ↗

(On Diff #184741)

Remove the first occurrence of "via". Any reason why the text here is different from the other two below?

[jhenderson]

lib/Support/CommandLine.cpp

1662–1663 ↗

(On Diff #184741)

I'm not sure I see a getOptionInfo function? There is printOptionInfo but that does the printing, and needs to know about spacing. I guess you could pull the common logic out into a function, but that would result in it being computed twice for every piece of help text, and would be a different design to the current design.

unittests/Support/CommandLineTest.cpp

1023 ↗

(On Diff #184741)

I can't remember there being a good reason, but I've tweaked all the comments anyway to clarify which case it is that we actually want to test and what we can't distinguish it from.

[jhenderson]

• Reword some unit-test comments.
• Pulled out some common logic into a small function.
• Renamed some variables to be more consistent with existing naming structure (this kind of switch is named in the following style: --<arg>=<option>).

[thopre]

lib/Support/CommandLine.cpp

1662–1663 ↗

(On Diff #184741)

Sorry yes I meant printOptionInfo. My thought was that printing would be done in a string and then getOptionWidth could be replaced by a strlen of sort. Yes it's a big redesign, I was just musing about it, sorry.

My comment was really about adding a skipOptionValue function that would return true when it's a ValueOptional option with empty value and value description. Trying to factor the rest of the code sounds more difficult but this is easily done.

[thopre]

Forgot some nits about the description (please ignore if it doesn't end up in the commit message):

• remove the last sentence about testing since you've added unit testing
• instead of describing a change I find that a small example like you did in your second quote block would be clearer
• you mention --option=var but your example is of the form -option=var which is confusing

[jhenderson]

In D57030#1382899, @thopre wrote:

Forgot some nits about the description (please ignore if it doesn't end up in the commit message):

• remove the last sentence about testing since you've added unit testing
• instead of describing a change I find that a small example like you did in your second quote block would be clearer
• you mention --option=var but your example is of the form -option=var which is confusing

Yeah, I actually changed it quite a bit in the original commit, but I since realised that there were other improvements I could make, so I've updated the description to match my planned submission. Please let me know if you are happy with the latest round of updates (both code and description).

[thopre]

LGTM. Thanks

llvm/trunk/lib/Support/CommandLine.cpp

 // has been specified yet.
 //
 static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
   if (O.ValueStr.empty())
     return DefaultMsg;
   return O.ValueStr;
 }
 
+static StringRef ArgPrefix = "  -";
+static StringRef ArgHelpPrefix = " - ";
+static size_t ArgPrefixesSize = ArgPrefix.size() + ArgHelpPrefix.size();
+
 //===----------------------------------------------------------------------===//
 // cl::alias class implementation
 //
 
 // Return the width of the option tag for printing...
-size_t alias::getOptionWidth() const { return ArgStr.size() + 6; }
+size_t alias::getOptionWidth() const { return ArgStr.size() + ArgPrefixesSize; }
 
 void Option::printHelpStr(StringRef HelpStr, size_t Indent,
-                                 size_t FirstLineIndentedBy) {
+  assert(Indent >= FirstLineIndentedBy);
   std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
-  outs().indent(Indent - FirstLineIndentedBy) << " - " << Split.first << "\n";
+  outs().indent(Indent - FirstLineIndentedBy)
+      << ArgHelpPrefix << Split.first << "\n";
   while (!Split.second.empty()) {
     Split = Split.second.split('\n');
     outs().indent(Indent) << Split.first << "\n";
   }
 }
 
 // Print out the option for the alias.
 void alias::printOptionInfo(size_t GlobalWidth) const {
-  outs() << "  -" << ArgStr;
-  printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);
+  outs() << ArgPrefix << ArgStr;
+  printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + ArgPrefixesSize);
 }
 
 //===----------------------------------------------------------------------===//
 // Parser Implementation code...
 //
 
 // basic_parser implementation
 //
 
 // Return the width of the option tag for printing...
 size_t basic_parser_impl::getOptionWidth(const Option &O) const {
   size_t Len = O.ArgStr.size();
   auto ValName = getValueName();
   if (!ValName.empty()) {
     size_t FormattingLen = 3;
     if (O.getMiscFlags() & PositionalEatsArgs)
       FormattingLen = 6;
     Len += getValueStr(O, ValName).size() + FormattingLen;
   }
 
-  return Len + 6;
+  return Len + ArgPrefixesSize;
 }
 
 // printOptionInfo - Print out information about this option.  The
 // to-be-maintained width is specified.
 //
 void basic_parser_impl::printOptionInfo(const Option &O,
                                         size_t GlobalWidth) const {
-  outs() << "  -" << O.ArgStr;
+  outs() << ArgPrefix << O.ArgStr;
 
   auto ValName = getValueName();
   if (!ValName.empty()) {
     if (O.getMiscFlags() & PositionalEatsArgs) {
       outs() << " <" << getValueStr(O, ValName) << ">...";
     } else {
       outs() << "=<" << getValueStr(O, ValName) << '>';
     }
   }
 
   Option::printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
 }
 
 void basic_parser_impl::printOptionName(const Option &O,
                                         size_t GlobalWidth) const {
-  outs() << "  -" << O.ArgStr;
+  outs() << ArgPrefix << O.ArgStr;
   outs().indent(GlobalWidth - O.ArgStr.size());
 }
 
 // parser<bool> implementation
 //
 bool parser<bool>::parse(Option &O, StringRef ArgName, StringRef Arg,
                          bool &Value) {
   if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
unsigned generic_parser_base::findOption(StringRef Name) {
 
   for (unsigned i = 0; i != e; ++i) {
     if (getOption(i) == Name)
       return i;
   }
   return e;
 }
 
+static StringRef EqValue = "=<value>";
+static StringRef EmptyOption = "<empty>";
+static StringRef OptionPrefix = "    =";
+static size_t OptionPrefixesSize = OptionPrefix.size() + ArgHelpPrefix.size();
+
+static bool shouldPrintOption(StringRef Name, StringRef Description,
+                              const Option &O) {
+  return O.getValueExpectedFlag() != ValueOptional || !Name.empty() ||
+         !Description.empty();
+}
+
 // Return the width of the option tag for printing...
 size_t generic_parser_base::getOptionWidth(const Option &O) const {
   if (O.hasArgStr()) {
-    size_t Size = O.ArgStr.size() + 6;
-    for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
-      Size = std::max(Size, getOption(i).size() + 8);
+    size_t Size = O.ArgStr.size() + ArgPrefixesSize + EqValue.size();
+    for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
+      StringRef Name = getOption(i);
+      if (!shouldPrintOption(Name, getDescription(i), O))
+        continue;
+      size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
+      Size = std::max(Size, NameSize + OptionPrefixesSize);
+    }
     return Size;
   } else {
     size_t BaseSize = 0;
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
       BaseSize = std::max(BaseSize, getOption(i).size() + 8);
     return BaseSize;
   }
 }
 
 // printOptionInfo - Print out information about this option.  The
 // to-be-maintained width is specified.
 //
 void generic_parser_base::printOptionInfo(const Option &O,
                                           size_t GlobalWidth) const {
   if (O.hasArgStr()) {
-    outs() << "  -" << O.ArgStr;
-    Option::printHelpStr(O.HelpStr, GlobalWidth, O.ArgStr.size() + 6);
+    // When the value is optional, first print a line just describing the
+    // option without values.
+    if (O.getValueExpectedFlag() == ValueOptional) {
+      for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
+        if (getOption(i).empty()) {
+          outs() << ArgPrefix << O.ArgStr;
+          Option::printHelpStr(O.HelpStr, GlobalWidth,
+                               O.ArgStr.size() + ArgPrefixesSize);
+          break;
+        }
+      }
+    }
 
+    outs() << ArgPrefix << O.ArgStr << EqValue;
+    Option::printHelpStr(O.HelpStr, GlobalWidth,
+                         O.ArgStr.size() + EqValue.size() + ArgPrefixesSize);
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
-      size_t NumSpaces = GlobalWidth - getOption(i).size() - 8;
-      outs() << "    =" << getOption(i);
-      outs().indent(NumSpaces) << " -   " << getDescription(i) << '\n';
+      StringRef OptionName = getOption(i);
+      StringRef Description = getDescription(i);
+      if (!shouldPrintOption(OptionName, Description, O))
+        continue;
+      assert(GlobalWidth >= OptionName.size() + OptionPrefixesSize);
+      size_t NumSpaces = GlobalWidth - OptionName.size() - OptionPrefixesSize;
+      outs() << OptionPrefix << OptionName;
+      if (OptionName.empty()) {
+        outs() << EmptyOption;
+        assert(NumSpaces >= EmptyOption.size());
+        NumSpaces -= EmptyOption.size();
+      }
+      if (!Description.empty())
+        outs().indent(NumSpaces) << ArgHelpPrefix << "  " << Description;
+      outs() << '\n';
     }
   } else {
     if (!O.HelpStr.empty())
       outs() << "  " << O.HelpStr << '\n';
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       auto Option = getOption(i);
       outs() << "    -" << Option;
       Option::printHelpStr(getDescription(i), GlobalWidth, Option.size() + 8);

llvm/trunk/tools/llvm-symbolizer/llvm-symbolizer.cpp

 
 static cl::opt<bool>
 ClUseSymbolTable("use-symbol-table", cl::init(true),
                  cl::desc("Prefer names in symbol table to names "
                           "in debug info"));
 
 static cl::opt<FunctionNameKind> ClPrintFunctions(
     "functions", cl::init(FunctionNameKind::LinkageName),
-    cl::desc("Print function name for a given address:"), cl::ValueOptional,
+    cl::desc("Print function name for a given address"), cl::ValueOptional,
     cl::values(clEnumValN(FunctionNameKind::None, "none", "omit function name"),
                clEnumValN(FunctionNameKind::ShortName, "short",
                           "print short function name"),
                clEnumValN(FunctionNameKind::LinkageName, "linkage",
                           "print function linkage name (default)"),
                // Sentinel value for unspecified value.
                clEnumValN(FunctionNameKind::LinkageName, "", "")));
 static cl::alias ClPrintFunctionsShort("f", cl::desc("Alias for -functions"),

llvm/trunk/unittests/Support/CommandLineTest.cpp

 //===- llvm/unittest/Support/CommandLineTest.cpp - CommandLine tests ------===//
 //
 // 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 "llvm/Support/CommandLine.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/StringSaver.h"
 #include "gtest/gtest.h"
 #include <fstream>
 #include <stdlib.h>
 #include <string>
 
TEST(CommandLineTest, GetCommandLineArguments) {
 
   EXPECT_TRUE(llvm::sys::path::filename(argv[0])
               .equals_lower("supporttests.exe"))
       << "Filename of test executable is "
       << llvm::sys::path::filename(argv[0]);
 }
 #endif
 
+class OutputRedirector {
+public:
+  OutputRedirector(int RedirectFD)
+      : RedirectFD(RedirectFD), OldFD(dup(RedirectFD)) {
+    if (OldFD == -1 ||
+        sys::fs::createTemporaryFile("unittest-redirect", "", NewFD,
+                                     FilePath) ||
+        dup2(NewFD, RedirectFD) == -1)
+      Valid = false;
+  }
+
+  ~OutputRedirector() {
+    dup2(OldFD, RedirectFD);
+    close(OldFD);
+    close(NewFD);
+  }
+
+  SmallVector<char, 128> FilePath;
+  bool Valid = true;
+
+private:
+  int RedirectFD;
+  int OldFD;
+  int NewFD;
+};
+
+struct AutoDeleteFile {
+  SmallVector<char, 128> FilePath;
+  ~AutoDeleteFile() {
+    if (!FilePath.empty())
+      sys::fs::remove(std::string(FilePath.data(), FilePath.size()));
+  }
+};
+
+class PrintOptionInfoTest : public ::testing::Test {
+public:
+  // Return std::string because the output of a failing EXPECT check is
+  // unreadable for StringRef. It also avoids any lifetime issues.
+  template <typename... Ts> std::string runTest(Ts... OptionAttributes) {
+    AutoDeleteFile File;
+    {
+      OutputRedirector Stdout(fileno(stdout));
+      if (!Stdout.Valid)
+        return "";
+      File.FilePath = Stdout.FilePath;
+
+      StackOption<OptionValue> TestOption(Opt, cl::desc(HelpText),
+                                          OptionAttributes...);
+      printOptionInfo(TestOption, 25);
+      outs().flush();
+    }
+    auto Buffer = MemoryBuffer::getFile(File.FilePath);
+    if (!Buffer)
+      return "";
+    return Buffer->get()->getBuffer().str();
+  }
+
+  enum class OptionValue { Val };
+  const StringRef Opt = "some-option";
+  const StringRef HelpText = "some help";
+
+private:
+  // This is a workaround for cl::Option sub-classes having their
+  // printOptionInfo functions private.
+  void printOptionInfo(const cl::Option &O, size_t Width) {
+    O.printOptionInfo(Width);
+  }
+};
+
+TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithoutSentinel) {
+  std::string Output =
+      runTest(cl::ValueOptional,
+              cl::values(clEnumValN(OptionValue::Val, "v1", "desc1")));
+
+  // clang-format off
+  EXPECT_EQ(Output, ("  -" + Opt + "=<value> - " + HelpText + "\n"
+                     "    =v1                -   desc1\n")
+                        .str());
+  // clang-format on
+}
+
+TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithSentinel) {
+  std::string Output = runTest(
+      cl::ValueOptional, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
+                                    clEnumValN(OptionValue::Val, "", "")));
+
+  // clang-format off
+  EXPECT_EQ(Output,
+            ("  -" + Opt + "         - " + HelpText + "\n"
+             "  -" + Opt + "=<value> - " + HelpText + "\n"
+             "    =v1                -   desc1\n")
+                .str());
+  // clang-format on
+}
+
+TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithSentinelWithHelp) {
+  std::string Output = runTest(
+      cl::ValueOptional, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
+                                    clEnumValN(OptionValue::Val, "", "desc2")));
+
+  // clang-format off
+  EXPECT_EQ(Output, ("  -" + Opt + "         - " + HelpText + "\n"
+                     "  -" + Opt + "=<value> - " + HelpText + "\n"
+                     "    =v1                -   desc1\n"
+                     "    =<empty>           -   desc2\n")
+                        .str());
+  // clang-format on
+}
+
+TEST_F(PrintOptionInfoTest, PrintOptionInfoValueRequiredWithEmptyValueName) {
+  std::string Output = runTest(
+      cl::ValueRequired, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
+                                    clEnumValN(OptionValue::Val, "", "")));
+
+  // clang-format off
+  EXPECT_EQ(Output, ("  -" + Opt + "=<value> - " + HelpText + "\n"
+                     "    =v1                -   desc1\n"
+                     "    =<empty>\n")
+                        .str());
+  // clang-format on
+}
+
+TEST_F(PrintOptionInfoTest, PrintOptionInfoEmptyValueDescription) {
+  std::string Output = runTest(
+      cl::ValueRequired, cl::values(clEnumValN(OptionValue::Val, "v1", "")));
+
+  // clang-format off
+  EXPECT_EQ(Output,
+            ("  -" + Opt + "=<value> - " + HelpText + "\n"
+             "    =v1\n").str());
+  // clang-format on
+}
+
+class GetOptionWidthTest : public ::testing::Test {
+public:
+  enum class OptionValue { Val };
+
+  template <typename... Ts>
+  size_t runTest(StringRef ArgName, Ts... OptionAttributes) {
+    StackOption<OptionValue> TestOption(ArgName, cl::desc("some help"),
+                                        OptionAttributes...);
+    return getOptionWidth(TestOption);
+  }
+
+private:
+  // This is a workaround for cl::Option sub-classes having their
+  // printOptionInfo
+  // functions private.
+  size_t getOptionWidth(const cl::Option &O) { return O.getOptionWidth(); }
+};
+
+TEST_F(GetOptionWidthTest, GetOptionWidthArgNameLonger) {
+  StringRef ArgName("a-long-argument-name");
+  Twine ExpectedStr = "  -" + ArgName + "=<value> - ";
+  EXPECT_EQ(
+      runTest(ArgName, cl::values(clEnumValN(OptionValue::Val, "v", "help"))),
+      ExpectedStr.str().size());
+}
+
+TEST_F(GetOptionWidthTest, GetOptionWidthFirstOptionNameLonger) {
+  StringRef OptName("a-long-option-name");
+  Twine ExpectedStr = "    =" + OptName + " - ";
+  EXPECT_EQ(
+      runTest("a", cl::values(clEnumValN(OptionValue::Val, OptName, "help"),
+                              clEnumValN(OptionValue::Val, "b", "help"))),
+      ExpectedStr.str().size());
+}
+
+TEST_F(GetOptionWidthTest, GetOptionWidthSecondOptionNameLonger) {
+  StringRef OptName("a-long-option-name");
+  Twine ExpectedStr = "    =" + OptName + " - ";
+  EXPECT_EQ(
+      runTest("a", cl::values(clEnumValN(OptionValue::Val, "b", "help"),
+                              clEnumValN(OptionValue::Val, OptName, "help"))),
+      ExpectedStr.str().size());
+}
+
+TEST_F(GetOptionWidthTest, GetOptionWidthEmptyOptionNameLonger) {
+  Twine ExpectedStr = "    =<empty> - ";
+  // The length of a=<value> (including indentation) is actually the same as the
+  // =<empty> string, so it is impossible to distinguish via testing the case
+  // where the empty string is picked from where the option name is picked.
+  EXPECT_EQ(runTest("a", cl::values(clEnumValN(OptionValue::Val, "b", "help"),
+                                    clEnumValN(OptionValue::Val, "", "help"))),
+            ExpectedStr.str().size());
+}
+
+TEST_F(GetOptionWidthTest,
+       GetOptionWidthValueOptionalEmptyOptionWithNoDescription) {
+  StringRef ArgName("a");
+  // The length of a=<value> (including indentation) is actually the same as the
+  // =<empty> string, so it is impossible to distinguish via testing the case
+  // where the empty string is ignored from where it is not ignored.
+  // The dash will not actually be printed, but the space it would take up is
+  // included to ensure a consistent column width.
+  Twine ExpectedStr = "  -" + ArgName + "=<value> - ";
+  EXPECT_EQ(runTest(ArgName, cl::ValueOptional,
+                    cl::values(clEnumValN(OptionValue::Val, "value", "help"),
+                               clEnumValN(OptionValue::Val, "", ""))),
+            ExpectedStr.str().size());
+}
+
+TEST_F(GetOptionWidthTest,
+       GetOptionWidthValueRequiredEmptyOptionWithNoDescription) {
+  // The length of a=<value> (including indentation) is actually the same as the
+  // =<empty> string, so it is impossible to distinguish via testing the case
+  // where the empty string is picked from where the option name is picked
+  Twine ExpectedStr = "    =<empty> - ";
+  EXPECT_EQ(runTest("a", cl::ValueRequired,
+                    cl::values(clEnumValN(OptionValue::Val, "value", "help"),
+                               clEnumValN(OptionValue::Val, "", ""))),
+            ExpectedStr.str().size());
+}
+
 }  // anonymous namespace