[llvm-symbolizer] Switch command line parsing from llvm::cl to OptTable

[MaskRay]

Summary

for the advantage outlined by D83639 ([OptTable] Support grouped short options)

Some behavior changes:

• -i={0,false} is removed. Use --no-inlines instead.
• --demangle={0,false} is removed. Use --no-demangle instead
• -untag-addresses={0,false} is removed. Use --no-untag-addresses instead

Added a higher level API OptTable::parseArgs which handles optional
initial options populated from an environment variable, expands response
files recursively, and parses options.

[rupprecht]

-f is a GNU option, so we should keep that for compatibility. Is there a reason it's being removed?
... actually, the patch says -f is dropped, but from the tablegen, it looks like it's still there?

LGTM to the general idea of replacing cl::opt with tablegen options for simple command line tools. Will take a look when the grouped option issue is addressed.

[MaskRay]

Ready for review.

[MaskRay]

In D83530#2144663, @rupprecht wrote:

-f is a GNU option, so we should keep that for compatibility. Is there a reason it's being removed?
... actually, the patch says -f is dropped, but from the tablegen, it looks like it's still there?

Fixed. A subsequent patch can drop -f= and -e= which are not conventional. This patch tries hard to stick with the current behavior to prevent surprise.

[jhenderson]

Honestly, I'm not convinced by the change, looking at this patch, at least not without much more stuff being added to common library code. In particular, I don't like how significant code needs adding in this patch to handle a number of things that were previously handled by the CommandLine code, for example help handling, type validation, and unknown argument detection.

In high-level terms, I don't think I really care either way which command line processing option is used, if it is straightforward to use, so I'm not opposed to a switchover, but at the moment it seems to be significantly complicating things, not simplifying, for relatively little gain.

(P.S. Don't forget to update documentation).

llvm/test/tools/llvm-symbolizer/untag-addresses.test

5

This isn't mentioned in the description, but probably should be.

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

75–76

Is this redundant now? You've added code that looks like it prints it.

[MaskRay]

Rebase after OptTable change was in.

[MaskRay]

In D83530#2146686, @jhenderson wrote:

Honestly, I'm not convinced by the change, looking at this patch, at least not without much more stuff being added to common library code. In particular, I don't like how significant code needs adding in this patch to handle a number of things that were previously handled by the CommandLine code, for example help handling, type validation, and unknown argument detection.

I think the library complexity is OK - 50 lines in OptTable.cpp which can be shared with other utilities.

In high-level terms, I don't think I really care either way which command line processing option is used, if it is straightforward to use, so I'm not opposed to a switchover, but at the moment it seems to be significantly complicating things, not simplifying, for relatively little gain.

cl::ParseCommandLineOptions has a baked-in interface, with a bunch of customizations the user may or may not want to accept. For example, -bool=0 & -bool=false may feel exotic for users coming from GNU getopt_long. --flag & --no-flag requires explicit position comparison.

OptTable appears to be a lighter interface with less customization. It does not call Tbl.findNearest, so the tool needs to do it by itself. Other than the few boilerplate lines I don't find the complexity is significant. We could move spelling checking to OptTable if more utilities want to use OptTable.

(P.S. Don't forget to update documentation).

After the switchover, the interface very closely matches the previous behavior. I find that there is not a need for a change to docs/CommandGuide/llvm-symbolizer.rst

-untag-addresses={0,false} is not documented (this looks to me a debug option). We can do it in a separate change.

[MaskRay]

Add --no-inlines to docs/CommandGuide/llvm-symbolizer.rst

[MaskRay]

Ping 😳

[jhenderson]

Sorry, I've been off for the past two working days, and had a bucket load of other reviews to look at too.

In D83530#2159094, @MaskRay wrote:

In D83530#2146686, @jhenderson wrote:

Honestly, I'm not convinced by the change, looking at this patch, at least not without much more stuff being added to common library code. In particular, I don't like how significant code needs adding in this patch to handle a number of things that were previously handled by the CommandLine code, for example help handling, type validation, and unknown argument detection.

I think the library complexity is OK - 50 lines in OptTable.cpp which can be shared with other utilities.

Right, I wasn't referring to the library complexity, I was referring to the fact that this change significantly increases the amount of code in llvm-symbolizer.cpp to parse the command-line, for only minimal benefit.

In high-level terms, I don't think I really care either way which command line processing option is used, if it is straightforward to use, so I'm not opposed to a switchover, but at the moment it seems to be significantly complicating things, not simplifying, for relatively little gain.

cl::ParseCommandLineOptions has a baked-in interface, with a bunch of customizations the user may or may not want to accept. For example, -bool=0 & -bool=false may feel exotic for users coming from GNU getopt_long. --flag & --no-flag requires explicit position comparison.

OptTable appears to be a lighter interface with less customization. It does not call Tbl.findNearest, so the tool needs to do it by itself. Other than the few boilerplate lines I don't find the complexity is significant. We could move spelling checking to OptTable if more utilities want to use OptTable.

You seem to be throwing out all the good things to simplify a couple of things though. Here is a (possibly non-exhaustive) list of things that were previously handled by the library, and now llvm-symbolizer has to do itself:

1. Response file usage.
2. Spell-checking of option names.
3. Argument type checking and conversion (e.g. to integer, enum etc).
4. Integer argument signedness checking.
5. Unknown argument handling.
6. Options specified via environment variables.
7. Help text printing.

Most, if not all of these are things that would be useful in other tools too, and should be therefore in the library, ideally on by default. For example, there are multiple places that want to use response files (LLD, llvm-objcopy etc) which have very similar, or even identical code to achieve that. I accept that there are some things in that list, where the default behaviour may need to differ (e.g. -h should not print help in llvm-readelf), but I reckon most of these are fairly rare.

It seems like there are two main things that you want to change. 1) To not support =0/=false style arguments, and 2) to not have to explicitly compare positions of --[no-]option examples. Would a different approach resolve this much more simply: add a new type cl::flag or similar, which implicitly adds a "no" prefix version, and turns off the =0 etc parsing, and handles the last-one-wins approach itself? If you don't think this is useful, then I'd expect to see the OptTable code expanded to address my above points.

(P.S. Don't forget to update documentation).

After the switchover, the interface very closely matches the previous behavior. I find that there is not a need for a change to docs/CommandGuide/llvm-symbolizer.rst

-untag-addresses={0,false} is not documented (this looks to me a debug option). We can do it in a separate change.

I actually asked to get that documented some time after the original review landed (see D65769). I wasn't referring to this though, I was referring to the new --no-inlines option, at the time (that's been added now). Also, there are several inline examples in the doc which use -i=0, which would still need updating.

[lichray]

You seem to be throwing out all the good things to simplify a couple of things though. Here is a (possibly non-exhaustive) list of things that were previously handled by the library, and now llvm-symbolizer has to do itself:

1. Response file usage.
2. Spell-checking of option names.
3. Argument type checking and conversion (e.g. to integers, enum, etc).
4. Integer argument signedness checking.
5. Unknown argument handling.
6. Options specified via environment variables.
7. Help text printing.

When looking at refactoring, I would emphasis direction over how close it is to some "ultimate" form. Global variables + llvm::cl isn't really sustainable, and the patch proposes to migrate away from it. To us, a community dealing with languages, it is quite natural to solve the problem of command-line parsing with a language. So I like the proposed solution.

The patch has implemented the features mentioned above, meets the minimal bar for refactoring -- not breaking anything, including user experience. They may not be implemented in some ideal places, but the progress models separation of concern. If we find that some demands are common enough, we can put them in OptTable API later.

[jhenderson]

In D83530#2181106, @lichray wrote:

You seem to be throwing out all the good things to simplify a couple of things though. Here is a (possibly non-exhaustive) list of things that were previously handled by the library, and now llvm-symbolizer has to do itself:

1. Response file usage.
2. Spell-checking of option names.
3. Argument type checking and conversion (e.g. to integers, enum, etc).
4. Integer argument signedness checking.
5. Unknown argument handling.
6. Options specified via environment variables.
7. Help text printing.

When looking at refactoring, I would emphasis direction over how close it is to some "ultimate" form. Global variables + llvm::cl isn't really sustainable, and the patch proposes to migrate away from it. To us, a community dealing with languages, it is quite natural to solve the problem of command-line parsing with a language. So I like the proposed solution.

The patch has implemented the features mentioned above, meets the minimal bar for refactoring -- not breaking anything, including user experience. They may not be implemented in some ideal places, but the progress models separation of concern. If we find that some demands are common enough, we can put them in OptTable API later.

I think your minimal refactoring bar is perhaps different to mine - I would argue that a refactor that makes the code more complicated is not a good idea.

I'm not arguing against moving to use OptTable in general, but I think every single one of my examples there already has at least one, and most more than one, other place that has the same or closely related requirement. We should improve the library first before trying to refactor this code to use it.

[lichray]

In D83530#2181366, @jhenderson wrote:

I think your minimal refactoring bar is perhaps different to mine - I would argue that a refactor that makes the code more complicated is not a good idea.

I'm not arguing against moving to use OptTable in general, but I think every single one of my examples there already has at least one, and most more than one, other place that has the same or closely related requirement. We should improve the library first before trying to refactor this code to use it.

I see some complicated code this time and made a few suggestions. However, to me, duplicated functionality does not imply complicated code. "Complicated" means that the code itself is difficult to comprehend, with or without some other place that has similar pieces. I'm fine with duplicating logic that preexists elsewhere during refactoring because we often need to look at more than one copies of the work to figure out a proper abstraction.

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

227

Uses of NewArgv finish here. Please consider moving these steps into a function.

232

Please consider moving this into a function with a name that suggests the intent.

288

For example, you may move these into a function called "decideHowToPrintFunctions," then you don't need to immediately show how to do that in code.

298

Line 250 seems to have similar logic. Please consider moving the functionality into a function.

[MaskRay]

Address comments

[MaskRay]

Expand some auto to opt::Arg

[lichray]

LGTM.

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

257–261

You might have forgotten to remove this line.

[MaskRay]

Delete an unused variable

[jhenderson]

I've already said my piece. I'm not prepared to accept this as-is until some effort is made to move the logic into a library, like it was before, so that the size and complexity of the tool's command-line parsing code is similar to what it was before.

In D83530#2182022, @lichray wrote:

In D83530#2181366, @jhenderson wrote:

I think your minimal refactoring bar is perhaps different to mine - I would argue that a refactor that makes the code more complicated is not a good idea.

I'm not arguing against moving to use OptTable in general, but I think every single one of my examples there already has at least one, and most more than one, other place that has the same or closely related requirement. We should improve the library first before trying to refactor this code to use it.

I see some complicated code this time and made a few suggestions. However, to me, duplicated functionality does not imply complicated code. "Complicated" means that the code itself is difficult to comprehend, with or without some other place that has similar pieces. I'm fine with duplicating logic that preexists elsewhere during refactoring because we often need to look at more than one copies of the work to figure out a proper abstraction.

There are many factors to complexity. Clearly a solution that is easy to understand but takes up 2/3/4 etc times as many lines of code is more complex than an equivalently simple to understand single line of code. Beyond that, using library interfaces which already do all the work is also simpler than writing the code out by hand, as long as the library interface is simple enough, and I believe the cl::opt one is fairly straightforward. Using libraries is also significantly more maintainable, and ensures that library improvements and fixes are picked up in the tool without having to be copied to every place doing the same thing. This change is going in the opposite direction on all counts as things stand.

[lichray]

In D83530#2186724, @jhenderson wrote:

I've already said my piece. I'm not prepared to accept this as-is until some effort is made to move the logic into a library, like it was before, so that the size and complexity of the tool's command-line parsing code is similar to what it was before.

In D83530#2182022, @lichray wrote:

I see some complicated code this time and made a few suggestions. However, to me, duplicated functionality does not imply complicated code. "Complicated" means that the code itself is difficult to comprehend, with or without some other place that has similar pieces. I'm fine with duplicating logic that preexists elsewhere during refactoring because we often need to look at more than one copies of the work to figure out a proper abstraction.

There are many factors to complexity. Clearly a solution that is easy to understand but takes up 2/3/4 etc times as many lines of code is more complex than an equivalently simple to understand single line of code. Beyond that, using library interfaces which already do all the work is also simpler than writing the code out by hand, as long as the library interface is simple enough, and I believe the cl::opt one is fairly straightforward. Using libraries is also significantly more maintainable, and ensures that library improvements and fixes are picked up in the tool without having to be copied to every place doing the same thing. This change is going in the opposite direction on all counts as things stand.

I thought you were talking about the complication aspect, now I understand that you are talking about complexity, thus the net of relations in code. I would say it would be ideal if every refactoring can maintain low complexity while building a better abstraction. But, as you may know, perfection is the enemy of progress. I doubt designing and implementing new features in OptTable are the uttermost important thing we should work on right now and the thing that motivates this change.

If we adopt this change, then the next person will have a basis that does not involve global variables to work on. Then he or she can do a survey on existing demand in other LLVM projects to tell if we want these features to appear in libraries. I deem this picture as progress. Telling contributors "to get your patch landed, you need to work on a problem that I have only a list of feature titles, entirely outside the component that I'm reviewing" often goes the opposite direction on maintaining sustainability in an open-source project.

[jhenderson]

In D83530#2186829, @lichray wrote:

I thought you were talking about the complication aspect, now I understand that you are talking about complexity, thus the net of relations in code. I would say it would be ideal if every refactoring can maintain low complexity while building a better abstraction. But, as you may know, perfection is the enemy of progress. I doubt designing and implementing new features in OptTable are the uttermost important thing we should work on right now and the thing that motivates this change.

I'm not sure I understand your distinction between complication and complexity. Perfection may well be the enemy of progress, but my point is that in its current state, I don't think this is progress. The global variables aren't causing any real issues (and indeed, they are effectively still there, just slightly hidden behind the tablegen abstraction). The issue is a lack of functionality in the cl::opt library for "last-one-wins" type functionality and similarly missing support for "--no-" type flags. Neither of these are exactly pressing issues, since there can already be implemented in fairly straightforward ways using the existing code. However, I'm willing to support changes to make them more natural, as long as they are net improvements. I think this change in its current form is one step forward (making the flags more natural) and about eight steps back (see list of things that the code now has to do itself which it didn't before).

If we adopt this change, then the next person will have a basis that does not involve global variables to work on. Then he or she can do a survey on existing demand in other LLVM projects to tell if we want these features to appear in libraries. I deem this picture as progress. Telling contributors "to get your patch landed, you need to work on a problem that I have only a list of feature titles, entirely outside the component that I'm reviewing" often goes the opposite direction on maintaining sustainability in an open-source project.

In this case, there are multiple clients already out there that require some or all of the features I've already listed. LLD and llvm-objcopy are just two examples. @MaskRay and I are already familiar with both code bases, so it's not like it's an arduous task to figure out that there is need for these features. LLVM is at its core a series of libraries, with various tools implemented on top of them. If we don't work to make sure as much useful code as possible is in those libraries (useful in the sense of there being more than one tool using it), then the wheel will be reinvented over-and-over again with all the corresponding costs and maintenance burden. For example, there have been issues in response file handling in one tool, because it was implemented differently there to others (I forget exactly which one and don't have the time right now to find the reference) - if these had all used a single version of code contained in a library, then the problem would never have occurred.

If on the other hand, we were to accept this patch in its current form, there's no requirement or indeed any real likelihood anybody will come along and add the missing functionality at some point, because the code already does the job it needs to. That leaves this code in a worse state than it currently is in.

[MaskRay]

Add a higher level API OptTable::parseArgs

[MaskRay]

Many thanks to @lichray's feedback!

1. Response file usage.
2. Spell-checking of option names.
3. Argument type checking and conversion (e.g. to integer, enum etc).
4. Integer argument signedness checking.
5. Unknown argument handling.
6. Options specified via environment variables.
7. Help text printing.

1, 2, 5 and 6 are handled by the new high-level API OptTable::parseArgs.

For 7, I think printHelp is as simple as if we handle it in the library.

For 3 and 4, they are handled by the same function parseIntArg and the underlying llvm::to_integer.
We could save some code by adding a new class representing the option type to .td files.
The appropriate abstraction requires more thoughts and probably needs some a few more cases
for us to form an opinion.

FWIW, llvm-symbolizer.cpp is 17 lines shorter than the previous revision.

[jhenderson]

Thanks. This looks much better to me. I hope to see other users for the new higher-level API in due course!

llvm/docs/CommandGuide/llvm-symbolizer.rst

222–223

I believe this option no longer exists?

llvm/include/llvm/Option/OptTable.h

236

argc -> Argc, argv -> Argv to silence the linter (same throughout).

llvm/lib/Option/OptTable.cpp

516

Nit: I might add a question mark to the end of this message, since it's a question.

[bd1976llvm]

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

272

tab?

[MaskRay]

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

272

No. New Phabricator displays this when it detects that the indentation changes.

[MaskRay]

Address comments

[jhenderson]

Looks good, but this probably needs a release note to highlight the change in how to disable certain options, in case anybody was relying on the old behaviour.

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

203

Argc, Argv here too.

[MaskRay]

argc -> Argc

[MaskRay]

Add some MetaVarName<>

[RKSimon]

@MaskRay http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/33877/ is failing with the error:

$ "c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\build\bin\llvm-symbolizer.exe" "-obj=c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm-project\llvm\test\tools\llvm-symbolizer\pdb/Inputs/test.exe" "-demangle=false"
# command stderr:
error: unknown argument '-demangle=false'

[MaskRay]

In D83530#2193865, @RKSimon wrote:

@MaskRay http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/33877/ is failing with the error:

$ "c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\build\bin\llvm-symbolizer.exe" "-obj=c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm-project\llvm\test\tools\llvm-symbolizer\pdb/Inputs/test.exe" "-demangle=false"
# command stderr:
error: unknown argument '-demangle=false'

Fixing

[MaskRay]

In D83530#2194261, @MaskRay wrote:

In D83530#2193865, @RKSimon wrote:

@MaskRay http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/33877/ is failing with the error:

$ "c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\build\bin\llvm-symbolizer.exe" "-obj=c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm-project\llvm\test\tools\llvm-symbolizer\pdb/Inputs/test.exe" "-demangle=false"
# command stderr:
error: unknown argument '-demangle=false'

Fixing

Fixed in 0729a772806e5ae38603c164c2f60e5e9f9e65e5. I don't have Windows or HAVE_DIA_SDK to test it, though.

[rupprecht]

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

287

This is documented as a flag, why was it removed?

[MaskRay]

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

287

It was unintentional. I think we may need to add/rename the negative option to --no-use-symbol-table. Some investigation is needed to create a test for it. I think previously it was probably a debug-purpose option, so there is no use-symbol-table=false test.

[Dor1s]

Fangrui, what made you think it's fine to remove documented options and break compatibility for the users of the tool?

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

36

@MaskRay you silently removed this option and didn't even update the documentation: https://llvm.org/docs/CommandGuide/llvm-symbolizer.html#cmdoption-llvm-symbolizer-use-symbol-table

[Dor1s]

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

287

Please avoid landing changes like this in future. Either do the investigation and make sure everything is fixed (i.e. documentation updated, no compatibility changes), or do not remove stuff silently like this.

[MaskRay]

In D83530#2253602, @Dor1s wrote:

Please avoid landing changes like this in future. Either do the investigation and make sure everything is fixed (i.e. documentation updated, no compatibility changes), or do not remove stuff silently like this.

I have mentioned that (nearly one month ago) it was my omission and I apologized for that.

Fangrui, what made you think it's fine to remove documented options and break compatibility for the users of the tool?

I don't think the option is properly documented, though. This is a large refactoring and it is difficult to ensure every option is good. I had tried very hard as you can probably see from the history of this patch. I shall also mention that this option is a completed untested feature so I somehow missed it. To be more constructive, do you have a use case where this option or its inverse is needed?

[MaskRay]

@Dor1s Sent D87067.

I don't know anyone uses --use-symbol-table or --no-use-symbol-table, so I will not add them. When we do so, we should ensure proper test coverage.

[Dor1s]

To be more constructive, do you have a use case where this option or its inverse is needed?

Yes, removal of this argument did break one pretty large system used by different projects / companies. We had to investigate and hotfix it on our end, but my point here that in general it's better not to break compatibility of the existing interfaces (doesn't matter whether we're talking about a cmd utility or an API), unless there's a very strong reason to do so.

llvm/docs/CommandGuide/llvm-symbolizer.rst

.. option:: --functions [=<none|short|linkage>], -f
 
   Specify the way function names are printed (omit function name, print short
   function name, or print full linkage name, respectively). Defaults to
   ``linkage``.
 
 .. option:: --help, -h
 
   Show help and usage for this command.
 
-.. option:: --help-list
-
-  Show help and usage for this command without grouping the options into categories.
-
 .. _llvm-symbolizer-opt-i:
 
 .. option:: --inlining, --inlines, -i
 
   If a source code location is in an inlined function, prints all the inlined
-  frames. Defaults to true.
+  frames. This is the default.
+
+.. option:: --no-inlines
+
+  Don't print inlined frames.
 
 .. option:: --no-demangle
 
   Don't print demangled function names.
 
 .. option:: --obj <path>, --exe, -e
 
   Path to object file to be symbolized. If ``-`` is specified, read the object
.. option:: --output-style <LLVM|GNU>
   .. code-block:: console
 
     $ llvm-symbolizer --obj=inlined.elf 0x4004be 0x400486 -p
     baz() at /tmp/test.cpp:11:18
      (inlined by) main at /tmp/test.cpp:15:0
 
     foo() at /tmp/test.cpp:6:3
 
-    $ llvm-symbolizer --output-style=LLVM --obj=inlined.elf 0x4004be 0x400486 -p -i=0
+    $ llvm-symbolizer --output-style=LLVM --obj=inlined.elf 0x4004be 0x400486 -p --no-inlines
     main at /tmp/test.cpp:11:18
 
     foo() at /tmp/test.cpp:6:3
 
-    $ llvm-symbolizer --output-style=GNU --obj=inlined.elf 0x4004be 0x400486 -p -i=0
+    $ llvm-symbolizer --output-style=GNU --obj=inlined.elf 0x4004be 0x400486 -p --no-inlines
     baz() at /tmp/test.cpp:11
     foo() at /tmp/test.cpp:6
 
     $ clang -g -fdebug-info-for-profiling test.cpp -o profiling.elf
-    $ llvm-symbolizer --output-style=GNU --obj=profiling.elf 0x401167 -p -i=0
+    $ llvm-symbolizer --output-style=GNU --obj=profiling.elf 0x401167 -p --no-inlines
     main at /tmp/test.cpp:15 (discriminator 2)
 
 .. option:: --pretty-print, -p
 
   Print human readable output. If :option:`--inlining` is specified, the
   enclosing scope is prefixed by (inlined by).
 
   .. code-block:: console

llvm/include/llvm/Option/OptTable.h

 //===- OptTable.h - Option Table --------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OPTION_OPTTABLE_H
 #define LLVM_OPTION_OPTTABLE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/OptSpecifier.h"
+#include "llvm/Support/StringSaver.h"
 #include <cassert>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
+template <typename Fn> class function_ref;
 
 namespace opt {
 
 class Arg;
 class ArgList;
 class InputArgList;
 class Option;
 
struct Info {
     const char *Values;
   };
 
 private:
   /// The option information table.
   std::vector<Info> OptionInfos;
   bool IgnoreCase;
   bool GroupedShortOptions = false;
+  const char *EnvVar = nullptr;
 
   unsigned TheInputOptionID = 0;
   unsigned TheUnknownOptionID = 0;
 
   /// The index of the first option which can be parsed (i.e., is not a
   /// special option like 'input' or 'unknown', and is not an option group).
   unsigned FirstSearchableIndex = 0;
 
public:
   }
 
   /// Get the meta-variable name to use when describing
   /// this options values in the help text.
   const char *getOptionMetaVar(OptSpecifier id) const {
     return getInfo(id).MetaVar;
   }
 
+  /// Specify the environment variable where initial options should be read.
+  void setInitialOptionsFromEnvironment(const char *E) { EnvVar = E; }
+
   /// Support grouped short options. e.g. -ab represents -a -b.
   void setGroupedShortOptions(bool Value) { GroupedShortOptions = Value; }
 
   /// Find possible value for given flags. This is used for shell
   /// autocompletion.
   ///
   /// \param [in] Option - Key flag like "-stdlib=" when "-stdlib=l"
   /// was passed to clang.
public:
   /// \param FlagsToExclude - Don't parse options with this flag.  Zero
   /// is the default and means exclude nothing.
   /// \return An InputArgList; on error this will contain all the options
   /// which could be parsed.
   InputArgList ParseArgs(ArrayRef<const char *> Args, unsigned &MissingArgIndex,
                          unsigned &MissingArgCount, unsigned FlagsToInclude = 0,
                          unsigned FlagsToExclude = 0) const;
 
+  /// A convenience helper which handles optional initial options populated from
+  /// an environment variable, expands response files recursively and parses
+  /// options.
+  ///
+  /// \param ErrorFn - Called on a formatted error message for missing arguments
+  /// or unknown options.
+  /// \return An InputArgList; on error this will contain all the options which
+  /// could be parsed.
+  InputArgList parseArgs(int Argc, char *const *Argv, OptSpecifier Unknown,
+                         StringSaver &Saver,
+                         function_ref<void(StringRef)> ErrorFn) const;
+
   /// Render the help text for an option table.
   ///
   /// \param OS - The stream to write the help text to.
   /// \param Usage - USAGE: Usage
   /// \param Title - OVERVIEW: Title
   /// \param FlagsToInclude - If non-zero, only include options with any
   ///                         of these flags set.
   /// \param FlagsToExclude - Exclude options with any of these flags set.

llvm/include/llvm/Support/CommandLine.h

 /// \return true if all @files were expanded successfully or there were none.
 bool ExpandResponseFiles(
     StringSaver &Saver, TokenizerCallback Tokenizer,
     SmallVectorImpl<const char *> &Argv, bool MarkEOLs = false,
     bool RelativeNames = false,
     llvm::vfs::FileSystem &FS = *llvm::vfs::getRealFileSystem(),
     llvm::Optional<llvm::StringRef> CurrentDir = llvm::None);
 
+/// A convenience helper which concatenates the options specified by the
+/// environment variable EnvVar and command line options, then expands response
+/// files recursively. The tokenizer is a predefined GNU or Windows one.
+/// \return true if all @files were expanded successfully or there were none.
+bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+                         StringSaver &Saver,
+                         SmallVectorImpl<const char *> &NewArgv);
+
 /// Mark all options not part of this category as cl::ReallyHidden.
 ///
 /// \param Category the category of options to keep displaying
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
 void HideUnrelatedOptions(cl::OptionCategory &Category,

llvm/lib/Option/OptTable.cpp

 //===- OptTable.cpp - Option Table Implementation -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Option/OptTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
-#include "llvm/Option/Option.h"
 #include "llvm/Option/OptSpecifier.h"
-#include "llvm/Option/OptTable.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h" // for expandResponseFiles
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstring>
 #include <map>
while (Index < End) {
     }
 
     Args.append(A);
   }
 
   return Args;
 }
 
+InputArgList OptTable::parseArgs(int Argc, char *const *Argv,
+                                 OptSpecifier Unknown, StringSaver &Saver,
+                                 function_ref<void(StringRef)> ErrorFn) const {
+  SmallVector<const char *, 0> NewArgv;
+  // The environment variable specifies initial options which can be overridden
+  // by commnad line options.
+  cl::expandResponseFiles(Argc, Argv, EnvVar, Saver, NewArgv);
+
+  unsigned MAI, MAC;
+  opt::InputArgList Args = ParseArgs(makeArrayRef(NewArgv), MAI, MAC);
+  if (MAC)
+    ErrorFn((Twine(Args.getArgString(MAI)) + ": missing argument").str());
+
+  // For each unknwon option, call ErrorFn with a formatted error message. The
+  // message includes a suggested alternative option spelling if available.
+  std::string Nearest;
+  for (const opt::Arg *A : Args.filtered(Unknown)) {
+    std::string Spelling = A->getAsString(Args);
+    if (findNearest(Spelling, Nearest) > 1)
+      ErrorFn("unknown argument '" + A->getAsString(Args) + "'");
+    else
+      ErrorFn("unknown argument '" + A->getAsString(Args) +
+              "', did you mean '" + Nearest + "'?");
+  }
+  return Args;
+}
+
 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
   const Option O = Opts.getOption(Id);
   std::string Name = O.getPrefixedName();
 
   // Add metavar, if used.
   switch (O.getKind()) {
   case Option::GroupClass: case Option::InputClass: case Option::UnknownClass:
     llvm_unreachable("Invalid option with help text.");

llvm/lib/Support/CommandLine.cpp

bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
   // stream. A failure here indicates a bug in the stack popping logic above.
   // Note that FileStack may have more than one element at this point because we
   // don't have a chance to pop the stack when encountering recursive files at
   // the end of the stream, so seeing that doesn't indicate a bug.
   assert(FileStack.size() > 0 && Argv.size() == FileStack.back().End);
   return AllExpanded;
 }
 
+bool cl::expandResponseFiles(int Argc, const char *const *Argv,
+                             const char *EnvVar, StringSaver &Saver,
+                             SmallVectorImpl<const char *> &NewArgv) {
+  auto Tokenize = Triple(sys::getProcessTriple()).isOSWindows()
+                      ? cl::TokenizeWindowsCommandLine
+                      : cl::TokenizeGNUCommandLine;
+  // The environment variable specifies initial options.
+  if (EnvVar)
+    if (llvm::Optional<std::string> EnvValue = sys::Process::GetEnv(EnvVar))
+      Tokenize(*EnvValue, Saver, NewArgv, /*MarkEOLs=*/false);
+
+  // Command line options can override the environment variable.
+  NewArgv.append(Argv + 1, Argv + Argc);
+  return ExpandResponseFiles(Saver, Tokenize, NewArgv);
+}
+
 bool cl::readConfigFile(StringRef CfgFile, StringSaver &Saver,
                         SmallVectorImpl<const char *> &Argv) {
   SmallString<128> AbsPath;
   if (sys::path::is_relative(CfgFile)) {
     llvm::sys::fs::current_path(AbsPath);
     llvm::sys::path::append(AbsPath, CfgFile);
     CfgFile = AbsPath.str();
   }

llvm/test/DebugInfo/debuglineinfo-path.ll

 ; Make sure that absolute source dir is detected correctly regardless of the platform.
 
 ; On powerpc llvm-nm describes win_func as a global variable, not a function. It breaks the test.
 ; It is not essential to DWARF path handling code we're testing here.
 ; UNSUPPORTED: powerpc
 ; REQUIRES: default_triple
 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t < %s
 ; RUN: llvm-nm --radix=o %t | grep posix_absolute_func > %t.posix_absolute_func
 ; RUN: llvm-nm --radix=o %t | grep posix_relative_func > %t.posix_relative_func
 ; RUN: llvm-nm --radix=o %t | grep win_func > %t.win_func
-; RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false --obj %t < %t.posix_absolute_func | FileCheck %s --check-prefix=POSIX_A
-; RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false --obj %t < %t.posix_relative_func | FileCheck %s --check-prefix=POSIX_R
-; RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false --obj %t < %t.win_func | FileCheck %s --check-prefix=WIN
+; RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle --obj %t < %t.posix_absolute_func | FileCheck %s --check-prefix=POSIX_A
+; RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle --obj %t < %t.posix_relative_func | FileCheck %s --check-prefix=POSIX_R
+; RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle --obj %t < %t.win_func | FileCheck %s --check-prefix=WIN
 
 ;POSIX_A: posix_absolute_func
 ;POSIX_A: /absolute/posix/path{{[\/]}}posix.c
 
 ;POSIX_R: posix_relative_func
 ;POSIX_R: /ABSOLUTE/CU/PATH{{[\/]}}relative/posix/path{{[\/]}}posix2.c
 
 ;WIN: win_func

llvm/test/tools/llvm-symbolizer/basic.s

 # RUN: echo -e "10\n11" | llvm-symbolizer --obj=%t.o | FileCheck %s
 
 # Check input addresses specified on the command-line.
 # RUN: llvm-symbolizer 0xa 0xb --obj=%t.o | FileCheck %s
 # RUN: llvm-symbolizer 10 11 --obj=%t.o | FileCheck %s
 
 # Check --obj aliases --exe, -e
 # RUN: llvm-symbolizer 0xa 0xb --exe=%t.o | FileCheck %s
+# RUN: llvm-symbolizer 0xa 0xb --exe %t.o | FileCheck %s
 # RUN: llvm-symbolizer 0xa 0xb -e %t.o | FileCheck %s
 # RUN: llvm-symbolizer 0xa 0xb -e=%t.o | FileCheck %s
 # RUN: llvm-symbolizer 0xa 0xb -e%t.o | FileCheck %s
 
 # CHECK: basic.s:5:0
 # CHECK: basic.s:6:0

llvm/test/tools/llvm-symbolizer/help.test

 RUN: llvm-symbolizer -h | FileCheck %s --check-prefix=SYMBOLIZER
 RUN: llvm-symbolizer --help | FileCheck %s --check-prefix=SYMBOLIZER
 RUN: llvm-addr2line -h | FileCheck %s --check-prefix=ADDR2LINE
 RUN: llvm-addr2line --help | FileCheck %s --check-prefix=ADDR2LINE
 
 SYMBOLIZER: OVERVIEW: llvm-symbolizer
-SYMBOLIZER: USAGE: llvm-symbolizer{{(.exe)?}} [options] <input addresses>...
+SYMBOLIZER: USAGE: llvm-symbolizer{{(.exe)?}} [options] addresses...
 SYMBOLIZER: @FILE
 
 ADDR2LINE: OVERVIEW: llvm-addr2line
-ADDR2LINE: USAGE: llvm-addr2line{{(.exe)?}} [options] <input addresses>...
+ADDR2LINE: USAGE: llvm-addr2line{{(.exe)?}} [options] addresses...
 ADDR2LINE: @FILE

llvm/test/tools/llvm-symbolizer/output-style-inlined.test

-This test checks that when inlined frames are not shown (-i=0) and the output
+This test checks that when inlined frames are not shown (--no-inlines) and the output
 style is set to GNU (--output-style=GNU) the name of an inlined function is not
 replaced with the name of the top caller function. At the same time, the current
 behavior of llvm-symbolizer is preserved with --output-style=LLVM or when
 the option is not specified.
 
-RUN: llvm-symbolizer -i=0 -e %p/Inputs/addr.exe 0x40054d \
+RUN: llvm-symbolizer --no-inlines -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=LLVM --implicit-check-not=inctwo
 
-RUN: llvm-symbolizer --output-style=LLVM -i=0 -e %p/Inputs/addr.exe 0x40054d \
+RUN: llvm-symbolizer --output-style=LLVM --no-inlines -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=LLVM --implicit-check-not=inctwo
 
-RUN: llvm-symbolizer --output-style=GNU -i=0 -e %p/Inputs/addr.exe 0x40054d \
+RUN: llvm-symbolizer --output-style=GNU --no-inlines -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=GNU --implicit-check-not=main
 
 RUN: llvm-addr2line -f -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=GNU --implicit-check-not=main
 
 RUN: llvm-addr2line --output-style=GNU -f -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=GNU --implicit-check-not=main
 
 RUN: llvm-addr2line --output-style=LLVM -f -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=LLVM --implicit-check-not=inctwo
 
 LLVM: main
 GNU: inctwo

llvm/test/tools/llvm-symbolizer/split-dwarf.test

 RUN: rm -rf %t
 RUN: mkdir -p %t
 
 RUN: cp %p/Inputs/split-dwarf-test.dwo %t
 
 RUN: cd %t
-RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false \
+RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle \
 RUN:    --obj=%p/Inputs/split-dwarf-test 0x400504 0x4004f4 | FileCheck --check-prefixes=SPLIT,DWO %s
 
 Ensure we get the same results in the absence of gmlt-like data in the executable but the presence of a .dwo file
 
 RUN: echo "%p/Inputs/split-dwarf-test-nogmlt 0x400504" >> %t.input
 RUN: echo "%p/Inputs/split-dwarf-test-nogmlt 0x4004f4" >> %t.input
-RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false \
+RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle \
 RUN:    --default-arch=i386 --obj=%p/Inputs/split-dwarf-test-nogmlt 0x400504 0x4004f4 | FileCheck --check-prefixes=SPLIT,DWO %s
 
 Ensure we get gmlt like results in the absence of a .dwo file but the presence of gmlt-like data in the executable
 
 RUN: rm %t/split-dwarf-test.dwo
 RUN: echo "%p/Inputs/split-dwarf-test 0x400504" >> %t.input
 RUN: echo "%p/Inputs/split-dwarf-test 0x4004f4" >> %t.input
-RUN: llvm-symbolizer --functions=linkage --inlining --demangle=false \
+RUN: llvm-symbolizer --functions=linkage --inlining --no-demangle \
 RUN:    --default-arch=i386 --obj=%p/Inputs/split-dwarf-test 0x400504 0x4004f4 | FileCheck --check-prefixes=SPLIT,NODWO %s
 
 DWO: _Z2f2v
 NODWO: {{^f2$}}
 SPLIT-NEXT: {{.*}}split-dwarf-test.cpp
 SPLIT-NEXT: main
 SPLIT-NEXT: {{.*}}split-dwarf-test.cpp
 
 SPLIT: _Z2f1v
 SPLIT-NEXT: {{.*}}split-dwarf-test.cpp

llvm/test/tools/llvm-symbolizer/unknown-argument.test

+# RUN: not llvm-symbolizer -x --flag 2>&1 | FileCheck %s
+
+# CHECK:      error: unknown argument '-x'{{$}}
+# CHECK-NEXT: error: unknown argument '--flag'{{$}}
+
+# RUN: not llvm-symbolizer --inline 2>&1 | FileCheck %s --check-prefix=SUGGEST
+
+# SUGGEST: error: unknown argument '--inline', did you mean '--inlines'?
+
+# RUN: not llvm-symbolizer -e 2>&1 | FileCheck %s --check-prefix=MISSING
+
+# MISSING: error: -e: missing argument

llvm/test/tools/llvm-symbolizer/untag-addresses.test

 # REQUIRES: x86-registered-target
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo DATA %t.o 0 | llvm-symbolizer | FileCheck --check-prefix=UNTAG %s
-# RUN: echo DATA %t.o 0 | llvm-symbolizer -untag-addresses=0 | FileCheck --check-prefix=NOUNTAG %s
+# RUN: echo DATA %t.o 0 | llvm-symbolizer --no-untag-addresses | FileCheck --check-prefix=NOUNTAG %s
 # RUN: echo DATA %t.o 0 | llvm-addr2line | FileCheck --check-prefix=NOUNTAG %s
 
 # UNTAG: foo
 # UNTAG: 0 4
 # NOUNTAG: ??
 # NOUNTAG: 0 0
 
 .data
 .globl foo
 .type foo, @object
 .size foo, 4
 foo = . + 0x1100000000000000
 .4byte 1

llvm/tools/llvm-symbolizer/CMakeLists.txt

 # FIXME: As we plan to execute llvm-symbolizer binary from compiler-rt
 # libraries, it has to be compiled for all supported targets (x86_64, i386 etc).
 # This means that we need LLVM libraries to be compiled for these
 # targets as well. Currently, there is no support for such a build strategy.
 
+set(LLVM_TARGET_DEFINITIONS Opts.td)
+tablegen(LLVM Opts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(SymbolizerOptsTableGen)
+
 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   DebugInfoPDB
   Demangle
   Object
+  Option
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-symbolizer
   llvm-symbolizer.cpp
+  DEPENDS
+  SymbolizerOptsTableGen
   )
 
 add_llvm_tool_symlink(llvm-addr2line llvm-symbolizer)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(addr2line llvm-symbolizer)
 endif()

llvm/tools/llvm-symbolizer/Opts.td

+include "llvm/Option/OptParser.td"
+
+multiclass B<string name, string help1, string help2> {
+  def NAME: Flag<["--", "-"], name>, HelpText<help1>;
+  def no_ # NAME: Flag<["--", "-"], "no-" # name>, HelpText<help2>;
+}
+
+multiclass Eq<string name, string help> {
+  def NAME #_EQ : Joined<["--", "-"], name #"=">,
+                  HelpText<help>;
+  def : Separate<["--", "-"], name>, Alias<!cast<Joined>(NAME #_EQ)>;
+}
+
+class F<string name, string help>: Flag<["--", "-"], name>, HelpText<help>;
+
+def addresses : F<"addresses", "Show address before line information">;
+defm adjust_vma
+    : Eq<"adjust-vma", "Add specified offset to object file addresses">,
+      MetaVarName<"<offset>">;
+def basenames : Flag<["--"], "basenames">, HelpText<"Strip directory names from paths">;
+defm debug_file_directory : Eq<"debug-file-directory", "Path to directory where to look for debug files">, MetaVarName<"<dir>">;
+defm default_arch : Eq<"default-arch", "Default architecture (for multi-arch objects)">;
+defm demangle : B<"demangle", "Demangle function names", "Don't demangle function names">;
+def functions : F<"functions", "Print function name for a given address">;
+def functions_EQ : Joined<["--"], "functions=">, HelpText<"Print function name for a given address">, Values<"none,short,linkage">;
+def help : F<"help", "Display this help">;
+defm dwp : Eq<"dwp", "Path to DWP file to be use for any split CUs">, MetaVarName<"<file>">;
+defm dsym_hint : Eq<"dsym-hint", "Path to .dSYM bundles to search for debug info for the object files">, MetaVarName<"<dir>">;
+defm fallback_debug_path : Eq<"fallback-debug-path", "Fallback path for debug binaries">, MetaVarName<"<dir>">;
+defm inlines : B<"inlines", "Print all inlined frames for a given address",
+                 "Do not print inlined frames">;
+defm obj
+    : Eq<"obj", "Path to object file to be symbolized (if not provided, "
+                "object file should be specified for each input line)">, MetaVarName<"<file>">;
+defm output_style
+    : Eq<"output-style", "Specify print style. Supported styles: LLVM, GNU">,
+      MetaVarName<"style">,
+      Values<"LLVM,GNU">;
+def pretty_print : F<"pretty-print", "Make the output more human friendly">;
+defm print_source_context_lines : Eq<"print-source-context-lines", "Print N lines of source file context">;
+def relative_address : F<"relative-address", "Interpret addresses as addresses relative to the image base">;
+def relativenames : F<"relativenames", "Strip the compilation directory from paths">;
+defm untag_addresses : B<"untag-addresses", "", "Remove memory tags from addresses before symbolization">;
+def use_native_pdb_reader : F<"use-native-pdb-reader", "Use native PDB functionality">;
+def verbose : F<"verbose", "Print verbose line info">;
+
+def : Flag<["-"], "a">, Alias<addresses>, HelpText<"Alias for --addresses">;
+def : F<"print-address", "Alias for --addresses">, Alias<addresses>;
+def : Flag<["-"], "C">, Alias<demangle>, HelpText<"Alias for --demangle">;
+def : Joined<["--"], "exe=">, Alias<obj_EQ>, HelpText<"Alias for --obj">, MetaVarName<"<file>">;
+def : Separate<["--"], "exe">, Alias<obj_EQ>, HelpText<"Alias for --obj">, MetaVarName<"<file>">;
+def : JoinedOrSeparate<["-"], "e">, Alias<obj_EQ>, HelpText<"Alias for --obj">, MetaVarName<"<file>">;
+def : Joined<["-"], "e=">, Alias<obj_EQ>, HelpText<"Alias for --obj">, MetaVarName<"<file>">;
+def : Flag<["-"], "f">, Alias<functions>, HelpText<"Alias for --functions">;
+def : Joined<["-"], "f=">, Alias<functions_EQ>, HelpText<"Alias for --functions=">;
+def : Flag<["-"], "h">, Alias<help>;
+def : Flag<["-"], "i">, Alias<inlines>, HelpText<"Alias for --inlines">;
+def : F<"inlining", "Alias for --inlines">, Alias<inlines>;
+def : Flag<["-"], "p">, Alias<pretty_print>, HelpText<"Alias for --pretty-print">;
+def : Flag<["-"], "s">, Alias<basenames>, HelpText<"Alias for --basenames">;

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

 //===-- llvm-symbolizer.cpp - Simple addr2line-like symbolizer ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This utility works much like "addr2line". It is able of transforming
 // tuples (module name, module offset) to code locations (function name,
 // file, line number, column number). It is targeted for compiler-rt tools
 // (especially AddressSanitizer and ThreadSanitizer) that can use it
 // to symbolize stack traces in their error reports.
 //
 //===----------------------------------------------------------------------===//
 
+#include "Opts.inc"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <string>
 
 using namespace llvm;
 using namespace symbolize;
 
-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::values(clEnumValN(FunctionNameKind::None, "none", "omit function name"),
-               clEnumValN(FunctionNameKind::ShortName, "short",
-                          "print short function name"),
-               clEnumValN(FunctionNameKind::LinkageName, "linkage",
-                          "print function linkage name"),
-               // Sentinel value for unspecified value.
-               clEnumValN(FunctionNameKind::LinkageName, "", "")));
-static cl::alias ClPrintFunctionsShort("f", cl::desc("Alias for -functions"),
-                                       cl::NotHidden, cl::Grouping,
-                                       cl::aliasopt(ClPrintFunctions));
-
-static cl::opt<bool>
-    ClUseRelativeAddress("relative-address", cl::init(false),
-                         cl::desc("Interpret addresses as relative addresses"),
-                         cl::ReallyHidden);
-
-static cl::opt<bool> ClUntagAddresses(
-    "untag-addresses", cl::init(true),
-    cl::desc("Remove memory tags from addresses before symbolization"));
-
-static cl::opt<bool>
-    ClPrintInlining("inlining", cl::init(true),
-                    cl::desc("Print all inlined frames for a given address"));
-static cl::alias
-    ClPrintInliningAliasI("i", cl::desc("Alias for -inlining"),
-                          cl::NotHidden, cl::aliasopt(ClPrintInlining),
-                          cl::Grouping);
-static cl::alias
-    ClPrintInliningAliasInlines("inlines", cl::desc("Alias for -inlining"),
-                                cl::NotHidden, cl::aliasopt(ClPrintInlining));
-
-static cl::opt<bool> ClBasenames("basenames", cl::init(false),
-                                 cl::desc("Strip directory names from paths"));
-static cl::alias ClBasenamesShort("s", cl::desc("Alias for -basenames"),
-                                  cl::NotHidden, cl::aliasopt(ClBasenames));
-
-static cl::opt<bool>
-    ClRelativenames("relativenames", cl::init(false),
-                    cl::desc("Strip the compilation directory from paths"));
-
-static cl::opt<bool>
-ClDemangle("demangle", cl::init(true), cl::desc("Demangle function names"));
-static cl::alias
-ClDemangleShort("C", cl::desc("Alias for -demangle"),
-                cl::NotHidden, cl::aliasopt(ClDemangle), cl::Grouping);
-static cl::opt<bool>
-ClNoDemangle("no-demangle", cl::init(false),
-             cl::desc("Don't demangle function names"));
-
-static cl::opt<std::string> ClDefaultArch("default-arch", cl::init(""),
-                                          cl::desc("Default architecture "
-                                                   "(for multi-arch objects)"));
-
-static cl::opt<std::string>
-ClBinaryName("obj", cl::init(""),
-             cl::desc("Path to object file to be symbolized (if not provided, "
-                      "object file should be specified for each input line)"));
-static cl::alias
-ClBinaryNameAliasExe("exe", cl::desc("Alias for -obj"),
-                     cl::NotHidden, cl::aliasopt(ClBinaryName));
-static cl::alias ClBinaryNameAliasE("e", cl::desc("Alias for -obj"),
-                                    cl::NotHidden, cl::Grouping, cl::Prefix,
-                                    cl::aliasopt(ClBinaryName));
-
-static cl::opt<std::string>
-    ClDwpName("dwp", cl::init(""),
-              cl::desc("Path to DWP file to be use for any split CUs"));
-
-static cl::list<std::string>
-ClDsymHint("dsym-hint", cl::ZeroOrMore,
-           cl::desc("Path to .dSYM bundles to search for debug info for the "
-                    "object files"));
-
-static cl::opt<bool>
-ClPrintAddress("print-address", cl::init(false),
-               cl::desc("Show address before line information"));
-static cl::alias
-ClPrintAddressAliasAddresses("addresses", cl::desc("Alias for -print-address"),
-                             cl::NotHidden, cl::aliasopt(ClPrintAddress));
-static cl::alias
-ClPrintAddressAliasA("a", cl::desc("Alias for -print-address"),
-                     cl::NotHidden, cl::aliasopt(ClPrintAddress), cl::Grouping);
-
-static cl::opt<bool>
-    ClPrettyPrint("pretty-print", cl::init(false),
-                  cl::desc("Make the output more human friendly"));
-static cl::alias ClPrettyPrintShort("p", cl::desc("Alias for -pretty-print"),
-                                    cl::NotHidden,
-                                    cl::aliasopt(ClPrettyPrint), cl::Grouping);
-
-static cl::opt<int> ClPrintSourceContextLines(
-    "print-source-context-lines", cl::init(0),
-    cl::desc("Print N number of source file context"));
-
-static cl::opt<bool> ClVerbose("verbose", cl::init(false),
-                               cl::desc("Print verbose line info"));
-
-static cl::opt<uint64_t>
-    ClAdjustVMA("adjust-vma", cl::init(0), cl::value_desc("offset"),
-                cl::desc("Add specified offset to object file addresses"));
+namespace {
+enum ID {
+  OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  OPT_##ID,
+#include "Opts.inc"
+#undef OPTION
+};
+
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Opts.inc"
+#undef PREFIX
+
+static const opt::OptTable::Info InfoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  {                                                                            \
+      PREFIX,      NAME,      HELPTEXT,                                        \
+      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
+      PARAM,       FLAGS,     OPT_##GROUP,                                     \
+      OPT_##ALIAS, ALIASARGS, VALUES},
+#include "Opts.inc"
+#undef OPTION
+};
+
+class SymbolizerOptTable : public opt::OptTable {
+public:
+  SymbolizerOptTable() : OptTable(InfoTable, true) {}
+};
+} // namespace
 
 static cl::list<std::string> ClInputAddresses(cl::Positional,
                                               cl::desc("<input addresses>..."),
                                               cl::ZeroOrMore);
 
-static cl::opt<std::string>
-    ClFallbackDebugPath("fallback-debug-path", cl::init(""),
-                        cl::desc("Fallback path for debug binaries."));
-
-static cl::list<std::string>
-    ClDebugFileDirectory("debug-file-directory", cl::ZeroOrMore,
-                         cl::value_desc("dir"),
-                         cl::desc("Path to directory where to look for debug "
-                                  "files."));
-
-static cl::opt<DIPrinter::OutputStyle>
-    ClOutputStyle("output-style", cl::init(DIPrinter::OutputStyle::LLVM),
-                  cl::desc("Specify print style"),
-                  cl::values(clEnumValN(DIPrinter::OutputStyle::LLVM, "LLVM",
-                                        "LLVM default style"),
-                             clEnumValN(DIPrinter::OutputStyle::GNU, "GNU",
-                                        "GNU addr2line style")));
-
-static cl::opt<bool>
-    ClUseNativePDBReader("use-native-pdb-reader", cl::init(0),
-                         cl::desc("Use native PDB functionality"));
-
-static cl::extrahelp
-    HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
-
 template<typename T>
 static bool error(Expected<T> &ResOrErr) {
   if (ResOrErr)
     return false;
   logAllUnhandledErrors(ResOrErr.takeError(), errs(),
                         "LLVMSymbolizer: error reading file: ");
   return true;
 }
 
 enum class Command {
   Code,
   Data,
   Frame,
 };
 
-static bool parseCommand(bool IsAddr2Line, StringRef InputString, Command &Cmd,
+static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
+                         StringRef InputString, Command &Cmd,
                          std::string &ModuleName, uint64_t &ModuleOffset) {
   const char kDelimiters[] = " \n\r";
   ModuleName = "";
   if (InputString.consume_front("CODE ")) {
     Cmd = Command::Code;
   } else if (InputString.consume_front("DATA ")) {
     Cmd = Command::Data;
   } else if (InputString.consume_front("FRAME ")) {
     Cmd = Command::Frame;
   } else {
     // If no cmd, assume it's CODE.
     Cmd = Command::Code;
   }
   const char *Pos = InputString.data();
   // Skip delimiters and parse input filename (if needed).
-  if (ClBinaryName.empty()) {
+  if (BinaryName.empty()) {
     Pos += strspn(Pos, kDelimiters);
     if (*Pos == '"' || *Pos == '\'') {
       char Quote = *Pos;
       Pos++;
       const char *End = strchr(Pos, Quote);
       if (!End)
         return false;
       ModuleName = std::string(Pos, End - Pos);
       Pos = End + 1;
     } else {
       int NameLength = strcspn(Pos, kDelimiters);
       ModuleName = std::string(Pos, NameLength);
       Pos += NameLength;
     }
   } else {
-    ModuleName = ClBinaryName;
+    ModuleName = BinaryName.str();
   }
   // Skip delimiters and parse module offset.
   Pos += strspn(Pos, kDelimiters);
   int OffsetLength = strcspn(Pos, kDelimiters);
   StringRef Offset(Pos, OffsetLength);
   // GNU addr2line assumes the offset is hexadecimal and allows a redundant
   // "0x" or "0X" prefix; do the same for compatibility.
   if (IsAddr2Line)
     Offset.consume_front("0x") || Offset.consume_front("0X");
   return !Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset);
 }
 
-static void symbolizeInput(bool IsAddr2Line, StringRef InputString,
-                           LLVMSymbolizer &Symbolizer, DIPrinter &Printer) {
+static void symbolizeInput(const opt::InputArgList &Args, uint64_t AdjustVMA,
+                           bool IsAddr2Line, DIPrinter::OutputStyle OutputStyle,
+                           StringRef InputString, LLVMSymbolizer &Symbolizer,
+                           DIPrinter &Printer) {
   Command Cmd;
   std::string ModuleName;
   uint64_t Offset = 0;
-  if (!parseCommand(IsAddr2Line, StringRef(InputString), Cmd, ModuleName,
-                    Offset)) {
+  if (!parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
+                    StringRef(InputString), Cmd, ModuleName, Offset)) {
     outs() << InputString << "\n";
     return;
   }
 
-  if (ClPrintAddress) {
+  if (Args.hasArg(OPT_addresses)) {
     outs() << "0x";
     outs().write_hex(Offset);
-    StringRef Delimiter = ClPrettyPrint ? ": " : "\n";
+    StringRef Delimiter = Args.hasArg(OPT_pretty_print) ? ": " : "\n";
     outs() << Delimiter;
   }
-  Offset -= ClAdjustVMA;
+  Offset -= AdjustVMA;
   if (Cmd == Command::Data) {
     auto ResOrErr = Symbolizer.symbolizeData(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get());
   } else if (Cmd == Command::Frame) {
     auto ResOrErr = Symbolizer.symbolizeFrame(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     if (!error(ResOrErr)) {
       for (DILocal Local : *ResOrErr)
         Printer << Local;
       if (ResOrErr->empty())
         outs() << "??\n";
     }
-  } else if (ClPrintInlining) {
+  } else if (Args.hasFlag(OPT_inlines, OPT_no_inlines, !IsAddr2Line)) {
     auto ResOrErr = Symbolizer.symbolizeInlinedCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     Printer << (error(ResOrErr) ? DIInliningInfo() : ResOrErr.get());
-  } else if (ClOutputStyle == DIPrinter::OutputStyle::GNU) {
-    // With ClPrintFunctions == FunctionNameKind::LinkageName (default)
-    // and ClUseSymbolTable == true (also default), Symbolizer.symbolizeCode()
+  } else if (OutputStyle == DIPrinter::OutputStyle::GNU) {
+    // With PrintFunctions == FunctionNameKind::LinkageName (default)
+    // and UseSymbolTable == true (also default), Symbolizer.symbolizeCode()
     // may override the name of an inlined function with the name of the topmost
     // caller function in the inlining chain. This contradicts the existing
     // behavior of addr2line. Symbolizer.symbolizeInlinedCode() overrides only
     // the topmost function, which suits our needs better.
     auto ResOrErr = Symbolizer.symbolizeInlinedCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get().getFrame(0));
   } else {
     auto ResOrErr = Symbolizer.symbolizeCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get());
   }
-  if (ClOutputStyle == DIPrinter::OutputStyle::LLVM)
+  if (OutputStyle == DIPrinter::OutputStyle::LLVM)
     outs() << "\n";
 }
 
+static void printHelp(bool IsAddr2Line, const SymbolizerOptTable &Tbl,
+                      raw_ostream &OS) {
+  StringRef ToolName = IsAddr2Line ? "llvm-addr2line" : "llvm-symbolizer";
+  const char HelpText[] = " [options] addresses...";
+  Tbl.PrintHelp(OS, (ToolName + HelpText).str().c_str(),
+                ToolName.str().c_str());
+  // TODO Replace this with OptTable API once it adds extrahelp support.
+  OS << "\nPass @FILE as argument to read options from FILE.\n";
+}
+
+static opt::InputArgList parseOptions(int Argc, char *Argv[], bool IsAddr2Line,
+                                      StringSaver &Saver,
+                                      SymbolizerOptTable &Tbl) {
+  Tbl.setGroupedShortOptions(true);
+  // The environment variable specifies initial options which can be overridden
+  // by commnad line options.
+  Tbl.setInitialOptionsFromEnvironment(IsAddr2Line ? "LLVM_ADDR2LINE_OPTS"
+                                                   : "LLVM_SYMBOLIZER_OPTS");
+  bool HasError = false;
+  opt::InputArgList Args =
+      Tbl.parseArgs(Argc, Argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
+        errs() << ("error: " + Msg + "\n");
+        HasError = true;
+      });
+  if (HasError)
+    exit(1);
+  if (Args.hasArg(OPT_help)) {
+    printHelp(IsAddr2Line, Tbl, outs());
+    exit(0);
+  }
+
+  return Args;
+}
+
+template <typename T>
+static void parseIntArg(const opt::InputArgList &Args, int ID, T &Value) {
+  if (const opt::Arg *A = Args.getLastArg(ID)) {
+    StringRef V(A->getValue());
+    if (!llvm::to_integer(V, Value, 0)) {
+      errs() << A->getSpelling() +
+                    ": expected a non-negative integer, but got '" + V + "'";
+      exit(1);
+    }
+  } else {
+    Value = 0;
+  }
+}
+
+static FunctionNameKind decideHowToPrintFunctions(const opt::InputArgList &Args,
+                                                  bool IsAddr2Line) {
+  if (Args.hasArg(OPT_functions))
+    return FunctionNameKind::LinkageName;
+  if (const opt::Arg *A = Args.getLastArg(OPT_functions_EQ))
+    return StringSwitch<FunctionNameKind>(A->getValue())
+        .Case("none", FunctionNameKind::None)
+        .Case("short", FunctionNameKind::ShortName)
+        .Default(FunctionNameKind::LinkageName);
+  return IsAddr2Line ? FunctionNameKind::None : FunctionNameKind::LinkageName;
+}
+
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  sys::InitializeCOMRAII COM(sys::COMThreadingMode::MultiThreaded);
 
   bool IsAddr2Line = sys::path::stem(argv[0]).contains("addr2line");
-
-  if (IsAddr2Line) {
-    ClDemangle.setInitialValue(false);
-    ClPrintFunctions.setInitialValue(FunctionNameKind::None);
-    ClPrintInlining.setInitialValue(false);
-    ClUntagAddresses.setInitialValue(false);
-    ClOutputStyle.setInitialValue(DIPrinter::OutputStyle::GNU);
-  }
-
-  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
-  cl::ParseCommandLineOptions(
-      argc, argv, IsAddr2Line ? "llvm-addr2line\n" : "llvm-symbolizer\n",
-      /*Errs=*/nullptr,
-      IsAddr2Line ? "LLVM_ADDR2LINE_OPTS" : "LLVM_SYMBOLIZER_OPTS");
-
-  // If both --demangle and --no-demangle are specified then pick the last one.
-  if (ClNoDemangle.getPosition() > ClDemangle.getPosition())
-    ClDemangle = !ClNoDemangle;
+  BumpPtrAllocator A;
+  StringSaver Saver(A);
+  SymbolizerOptTable Tbl;
+  opt::InputArgList Args = parseOptions(argc, argv, IsAddr2Line, Saver, Tbl);
 
   LLVMSymbolizer::Options Opts;
-  Opts.PrintFunctions = ClPrintFunctions;
-  Opts.UseSymbolTable = ClUseSymbolTable;
-  Opts.Demangle = ClDemangle;
-  Opts.RelativeAddresses = ClUseRelativeAddress;
-  Opts.UntagAddresses = ClUntagAddresses;
-  Opts.DefaultArch = ClDefaultArch;
-  Opts.FallbackDebugPath = ClFallbackDebugPath;
-  Opts.DWPName = ClDwpName;
-  Opts.DebugFileDirectory = ClDebugFileDirectory;
-  Opts.UseNativePDBReader = ClUseNativePDBReader;
+  uint64_t AdjustVMA;
+  unsigned SourceContextLines;
+  parseIntArg(Args, OPT_adjust_vma_EQ, AdjustVMA);
+  if (const opt::Arg *A = Args.getLastArg(OPT_basenames, OPT_relativenames)) {
+    Opts.PathStyle =
+        A->getOption().matches(OPT_basenames)
+            ? DILineInfoSpecifier::FileLineInfoKind::BaseNameOnly
+            : DILineInfoSpecifier::FileLineInfoKind::RelativeFilePath;
+  } else {
     Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
-  // If both --basenames and --relativenames are specified then pick the last
-  // one.
-  if (ClBasenames.getPosition() > ClRelativenames.getPosition())
-    Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::BaseNameOnly;
-  else if (ClRelativenames)
-    Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::RelativeFilePath;
-
-  for (const auto &hint : ClDsymHint) {
-    if (sys::path::extension(hint) == ".dSYM") {
-      Opts.DsymHints.push_back(hint);
+  }
+  Opts.DebugFileDirectory = Args.getAllArgValues(OPT_debug_file_directory_EQ);
+  Opts.DefaultArch = Args.getLastArgValue(OPT_default_arch_EQ).str();
+  Opts.Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, !IsAddr2Line);
+  Opts.DWPName = Args.getLastArgValue(OPT_dwp_EQ).str();
+  Opts.FallbackDebugPath =
+      Args.getLastArgValue(OPT_fallback_debug_path_EQ).str();
+  Opts.PrintFunctions = decideHowToPrintFunctions(Args, IsAddr2Line);
+  parseIntArg(Args, OPT_print_source_context_lines_EQ, SourceContextLines);
+  Opts.RelativeAddresses = Args.hasArg(OPT_relative_address);
+  Opts.UntagAddresses =
+      Args.hasFlag(OPT_untag_addresses, OPT_no_untag_addresses, !IsAddr2Line);
+  Opts.UseNativePDBReader = Args.hasArg(OPT_use_native_pdb_reader);
+  Opts.UseSymbolTable = true;
+
+  for (const opt::Arg *A : Args.filtered(OPT_dsym_hint_EQ)) {
+    StringRef Hint(A->getValue());
+    if (sys::path::extension(Hint) == ".dSYM") {
+      Opts.DsymHints.emplace_back(Hint);
     } else {
-      errs() << "Warning: invalid dSYM hint: \"" << hint <<
-                "\" (must have the '.dSYM' extension).\n";
+      errs() << "Warning: invalid dSYM hint: \"" << Hint
+             << "\" (must have the '.dSYM' extension).\n";
     }
   }
-  LLVMSymbolizer Symbolizer(Opts);
 
-  DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None,
-                    ClPrettyPrint, ClPrintSourceContextLines, ClVerbose,
-                    ClOutputStyle);
+  auto OutputStyle =
+      IsAddr2Line ? DIPrinter::OutputStyle::GNU : DIPrinter::OutputStyle::LLVM;
+  if (const opt::Arg *A = Args.getLastArg(OPT_output_style_EQ)) {
+    OutputStyle = strcmp(A->getValue(), "GNU") == 0
+                      ? DIPrinter::OutputStyle::GNU
+                      : DIPrinter::OutputStyle::LLVM;
+  }
+
+  LLVMSymbolizer Symbolizer(Opts);
+  DIPrinter Printer(outs(), Opts.PrintFunctions != FunctionNameKind::None,
+                    Args.hasArg(OPT_pretty_print), SourceContextLines,
+                    Args.hasArg(OPT_verbose), OutputStyle);
 
-  if (ClInputAddresses.empty()) {
+  std::vector<std::string> InputAddresses = Args.getAllArgValues(OPT_INPUT);
+  if (InputAddresses.empty()) {
     const int kMaxInputStringLength = 1024;
     char InputString[kMaxInputStringLength];
 
     while (fgets(InputString, sizeof(InputString), stdin)) {
       // Strip newline characters.
       std::string StrippedInputString(InputString);
       StrippedInputString.erase(
           std::remove_if(StrippedInputString.begin(), StrippedInputString.end(),
                          [](char c) { return c == '\r' || c == '\n'; }),
           StrippedInputString.end());
-      symbolizeInput(IsAddr2Line, StrippedInputString, Symbolizer, Printer);
+      symbolizeInput(Args, AdjustVMA, IsAddr2Line, OutputStyle,
+                     StrippedInputString, Symbolizer, Printer);
       outs().flush();
     }
   } else {
-    for (StringRef Address : ClInputAddresses)
-      symbolizeInput(IsAddr2Line, Address, Symbolizer, Printer);
+    for (StringRef Address : InputAddresses)
+      symbolizeInput(Args, AdjustVMA, IsAddr2Line, OutputStyle, Address,
+                     Symbolizer, Printer);
   }
 
   return 0;
 }