[llvm-symbolizer] Add llvm-addr2line

[ikudrin]

Summary

llvm-symbolizer, with the latest updates, works very similarly to GNU's addr2line. The main difference is in the defaults both tools use. In particular:

• llvm-symbolizer has "-I", "-f" and "-C" options ON by default;
• llvm-symbolizer prints line and column while addr2line prints only a line.
• With "-f -i=0", llvm-symbolizer replaces the name of an inlined function with the name from the symbol table, i. e., the top caller function in the inlining chain. addr2line preserves the name of the inlined function.

This patch adds an alias for llvm-symbolizer which is tuned to follow the behavior of addr2line better.

[rupprecht]

(adding a few others that may be interested)

include/llvm/DebugInfo/Symbolize/DIPrinter.h

33

This should be the enum itself, not a bool

lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

230–231

I don't really understand this bit... would it make more sense to have this happen a level up? i.e. make the caller of this check UseSymbolTableForInlinedFunctions and call the right method instead?

test/tools/llvm-symbolizer/addr2line.test

21

nit: include a newline at the end

tools/llvm-symbolizer/llvm-symbolizer.cpp

262

The parameter should be commented, i.e. /*UseSymbolTableForInlinedFunctions=*/!IsAddr2Line

[jhenderson]

test/tools/llvm-symbolizer/addr2line.test

1

Rather than adding a test that tests each of the places where llvm-addr2line is different to llvm-symbolizer, I think it would make a lot more sense to add test cases using llvm-addr2line to the existing llvm-symbolizer tests, where the behaviour is different.

tools/llvm-symbolizer/llvm-symbolizer.cpp

97–99

This change should be separated out into a different patch, as it affects llvm-symbolizer behaviour too.

149

Test cases for this new option?

254

Maybe worth having a basic test that shows that the usage text is correct for both tools.

[jhenderson]

lib/DebugInfo/Symbolize/DIPrinter.cpp

85–86

Thinking about it, it might be nice if this was under a new dedicated switch, that can be individually be enabled and disabled, so that llvm-addr2line users can print that without changing the other defaults.

[ikudrin]

• Rebased the patch to the current tip;
• Moved the code which handles differences in printing source positions in llvm-symbolizer.cpp;
• Reworked tests.

[lebedev.ri]

I guess it's not considered a common practice, but i think it would be a really good idea to add a docs page for the new tool at the same time. Else it will be forgotten, much like for half of other tools..

[jhenderson]

In D60067#1462784, @lebedev.ri wrote:

I guess it's not considered a common practice, but i think it would be a really good idea to add a docs page for the new tool at the same time. Else it will be forgotten, much like for half of other tools..

I agree, although it's worth noting that llvm-symbolizer DOES have this documentation, so it may be worth piggy-backing on that rather than writing an entirely new doc.

Overall, I'm basically happy with this change. One of the major points brought up at the BoF and round table for LLVM binutils at the just-gone Euro LLVM Developers' Meeting was that we might want to consider a machine-readable output style in the future. If we do that, we will likely need to refactor how this all works (i.e. how LLVM style, GNU style and machine-readable style get printed), but that's probably beyond the scope of this change. Getting the new tool in allows people to start using it now.

test/tools/llvm-symbolizer/sym.test

64 ↗

(On Diff #194687)

You should add a {{$}} to the end of this line as it would also match "inctwo".

tools/llvm-symbolizer/llvm-symbolizer.cpp

236

suites -> suits

[ikudrin]

• Added a doc page for llvm-addr2line. I'll really appreciate any corrections.
• Addressed other review comments.

[ikudrin]

• Fixed a typo.

[jhenderson]

LGTM, but it would be worth getting a second pair of eyes on the documentation who is more familiar with how the markup works, to make sure it is correct.

[rupprecht]

(requesting changes for one small bit, otherwise lgtm)

docs/CommandGuide/llvm-addr2line.rst

7 ↗

(On Diff #194854)

I think this should be [*options*] (e.g. see llvm-objdump.rst)

tools/llvm-symbolizer/llvm-symbolizer.cpp

230

I think this should be else if (ClOutputStyle == OutputStyle::GNU), if someone wants to use llvm-symbolizer directly but still have GNU addr2line compatability.

[rupprecht]

In D60067#1464211, @jhenderson wrote:

LGTM, but it would be worth getting a second pair of eyes on the documentation who is more familiar with how the markup works, to make sure it is correct.

I don't speak rst, but I'm pretty familiar with markdown, and there was a thread last year that received positive support for switching rst to markdown [1][2], so I think people are in favor of it. But I'm fine checking this in now as .rst for consistency. Worst case scenario, it doesn't render, and someone can commit a patch to fix it. Nothing will stop compiling :)
(We can/should do a rst->md conversion for all the binutils/command guide docs as a whole, in a separate patch)

Also: looks like the llvm website definitely supports markdown for other docs, e.g. see this page: http://llvm.org/docs/TestSuiteGuide.html (generated from docs/TestSuiteGuide.md)

[1] https://lists.llvm.org/pipermail/llvm-dev/2018-March/122234.html
[2] http://lists.llvm.org/pipermail/llvm-dev/2018-April/122304.html

[jhenderson]

In D60067#1466153, @rupprecht wrote:

But I'm fine checking this in now as .rst for consistency. Worst case scenario, it doesn't render, and someone can commit a patch to fix it. Nothing will stop compiling :)

FWIW, there is actually a build bot that does the conversion, and it fails if the syntax is bad, so we should aim to get it right first time if possible.

[ikudrin]

• rst -> md.
• Made printing of an empty line depend on the -output-style option instead of the tool name.

[ikudrin]

tools/llvm-symbolizer/llvm-symbolizer.cpp

230

I'm not sure. Output style should define the way the information is displayed, but not affect the information itself. It'd be a bit unexpected, I think.

[jhenderson]

tools/llvm-symbolizer/llvm-symbolizer.cpp

230

I actually agree with Jordan, so I'm retracting my LGTM.

We should try to have a consistent strategy between the tools. llvm-readobj already has an --elf-output-style switch, which switches the printing style between LLVM and GNU (and could be used for others in the future). llvm-readelf changes the default of that switch, but is otherwise essentially identical. There are other differences to do with command-line parsing, that are solely driven by the tool name.

The same should exist for llvm-symbolizer/llvm-addr2line. The tool's output style should be configured via the switch, with defaults of LLVM and GNU respectively. In some cases with might allow overriding of some behaviours. The command-line behaviour will still be driven by the tool name.

[ikudrin]

OK, let be it.

[rupprecht]

In D60067#1466236, @jhenderson wrote:

In D60067#1466153, @rupprecht wrote:

But I'm fine checking this in now as .rst for consistency. Worst case scenario, it doesn't render, and someone can commit a patch to fix it. Nothing will stop compiling :)

FWIW, there is actually a build bot that does the conversion, and it fails if the syntax is bad, so we should aim to get it right first time if possible.

Ok, but it's still just a build bot, not real code :p
It would be good to check the build bot status after submitting to make sure it handles the new file correctly. It looks fine when I throw it at an md viewer, but I'm not sure what the build bot does to parse it.

[rupprecht]

Thanks for adding this!

[jhenderson]

Could we have a test case that shows that llvm-symbolizer --output-style=GNU produces the same as llvm-addr2line for the inlining stuff, please?

[ikudrin]

It looks like the changes for --output-style should go into a separate patch with the corresponding tests.

[ikudrin]

• Extracted the changes for --output-style into a separate patch, D60770.

[jhenderson]

Code all looks good, but you should talk about the effect of --output-style on the output for both llvm-symbolizer and llvm-addr2line as appropriate.

[ikudrin]

In D60067#1468404, @jhenderson wrote:

Code all looks good, but you should talk about the effect of --output-style on the output for both llvm-symbolizer and llvm-addr2line as appropriate.

Do you want this option to be added to the documentation about llvm-symbolizer or something else? Or you meant other places where this info should be added?

[jhenderson]

In D60067#1469782, @ikudrin wrote:

In D60067#1468404, @jhenderson wrote:

Code all looks good, but you should talk about the effect of --output-style on the output for both llvm-symbolizer and llvm-addr2line as appropriate.

Do you want this option to be added to the documentation about llvm-symbolizer or something else? Or you meant other places where this info should be added?

It would be good to have it in the llvm-symbolizer document (if it doesn't already exist there), documenting the style differences. I think it should also be explicitly mentioned in the llvm-addr2line document (but just saying the default is different is fine for that).

[ikudrin]

• Rebased on top of D60816; updated the documentation accordingly.

[jhenderson]

LGTM.

include/llvm/DebugInfo/Symbolize/DIPrinter.h

 
 class DIPrinter {
   raw_ostream &OS;
   bool PrintFunctionNames;
   bool PrintPretty;
   int PrintSourceContext;
   bool Verbose;
   bool Basenames;
+  bool OutputStyleGNU;
 
   void print(const DILineInfo &Info, bool Inlined);
   void printContext(const std::string &FileName, int64_t Line);
 
 public:
+  enum class OutputStyle { LLVM, GNU };
+
   DIPrinter(raw_ostream &OS, bool PrintFunctionNames = true,
             bool PrintPretty = false, int PrintSourceContext = 0,
-            bool Verbose = false, bool Basenames = false)
+            bool Verbose = false, bool Basenames = false,
+            OutputStyle Style = OutputStyle::LLVM)
       : OS(OS), PrintFunctionNames(PrintFunctionNames),
         PrintPretty(PrintPretty), PrintSourceContext(PrintSourceContext),
-        Verbose(Verbose), Basenames(Basenames) {}
+        Verbose(Verbose), Basenames(Basenames),
+        OutputStyleGNU(Style == OutputStyle::GNU) {}
 
   DIPrinter &operator<<(const DILineInfo &Info);
   DIPrinter &operator<<(const DIInliningInfo &Info);
   DIPrinter &operator<<(const DIGlobal &Global);
 };
 }
 }
 
 #endif
 

include/llvm/DebugInfo/Symbolize/SymbolizableModule.h

 namespace symbolize {
 
 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
 
 class SymbolizableModule {
 public:
   virtual ~SymbolizableModule() = default;
 
-  virtual DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
-                                   FunctionNameKind FNKind,
-                                   bool UseSymbolTable) const = 0;
+  virtual DILineInfo
+  symbolizeCode(object::SectionedAddress ModuleOffset, FunctionNameKind FNKind,
+                bool UseSymbolTable,
+                bool UseSymbolTableForInlinedFunctions) const = 0;
   virtual DIInliningInfo
   symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                        FunctionNameKind FNKind, bool UseSymbolTable) const = 0;
   virtual DIGlobal
   symbolizeData(object::SectionedAddress ModuleOffset) const = 0;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   virtual bool isWin32Module() const = 0;

include/llvm/DebugInfo/Symbolize/Symbolize.h

 
 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
 
 class LLVMSymbolizer {
 public:
   struct Options {
     FunctionNameKind PrintFunctions;
     bool UseSymbolTable : 1;
+    // Allow LLVMSymbolizer::symbolizeCode to replace the name of an inlined
+    // function with the name from the symbol table, which corresponds to
+    // the topmost caller function in the inlining chain.
+    bool UseSymbolTableForInlinedFunctions : 1;
     bool Demangle : 1;
     bool RelativeAddresses : 1;
     std::string DefaultArch;
     std::vector<std::string> DsymHints;
     std::string FallbackDebugPath;
 
     Options(FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName,
             bool UseSymbolTable = true, bool Demangle = true,
             bool RelativeAddresses = false, std::string DefaultArch = "",
-            std::string FallbackDebugPath = "")
+            std::string FallbackDebugPath = "",
+            bool UseSymbolTableForInlinedFunctions = true)
         : PrintFunctions(PrintFunctions), UseSymbolTable(UseSymbolTable),
           Demangle(Demangle), RelativeAddresses(RelativeAddresses),
           DefaultArch(std::move(DefaultArch)),
-          FallbackDebugPath(std::move(FallbackDebugPath)) {}
+          FallbackDebugPath(std::move(FallbackDebugPath)),
+          UseSymbolTableForInlinedFunctions(UseSymbolTableForInlinedFunctions) {
+    }
   };
 
   LLVMSymbolizer(const Options &Opts = Options()) : Opts(Opts) {}
 
   ~LLVMSymbolizer() {
     flush();
   }
 

lib/DebugInfo/Symbolize/DIPrinter.cpp

if (PrintFunctionNames) {
     OS << Prefix << FunctionName << Delimiter;
   }
   std::string Filename = Info.FileName;
   if (Filename == kDILineInfoBadString)
     Filename = kBadString;
   else if (Basenames)
     Filename = llvm::sys::path::filename(Filename);
   if (!Verbose) {
-    OS << Filename << ":" << Info.Line << ":" << Info.Column << "\n";
+    OS << Filename << ":" << Info.Line;
+    if (!OutputStyleGNU)
+      OS << ":" << Info.Column;
+    OS << "\n";
     printContext(Filename, Info.Line);
     return;
   }
   OS << "  Filename: " << Filename << "\n";
   if (Info.StartLine)
     OS << "Function start line: " << Info.StartLine << "\n";
   OS << "  Line: " << Info.Line << "\n";
   OS << "  Column: " << Info.Column << "\n";

lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

 
 namespace symbolize {
 
 class SymbolizableObjectFile : public SymbolizableModule {
 public:
   static ErrorOr<std::unique_ptr<SymbolizableObjectFile>>
   create(object::ObjectFile *Obj, std::unique_ptr<DIContext> DICtx);
 
-  DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
-                           FunctionNameKind FNKind,
-                           bool UseSymbolTable) const override;
+  DILineInfo
+  symbolizeCode(object::SectionedAddress ModuleOffset, FunctionNameKind FNKind,
+                bool UseSymbolTable,
+                bool UseSymbolTableForInlinedFunctions) const override;
   DIInliningInfo symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                                       FunctionNameKind FNKind,
                                       bool UseSymbolTable) const override;
   DIGlobal symbolizeData(object::SectionedAddress ModuleOffset) const override;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   bool isWin32Module() const override;
 

lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

bool SymbolizableObjectFile::shouldOverrideWithSymbolTable(
   // When DWARF is used with -gline-tables-only / -gmlt, the symbol table gives
   // better answers for linkage names than the DIContext. Otherwise, we are
   // probably using PEs and PDBs, and we shouldn't do the override. PE files
   // generally only contain the names of exported symbols.
   return FNKind == FunctionNameKind::LinkageName && UseSymbolTable &&
          isa<DWARFContext>(DebugInfoContext.get());
 }
 
-DILineInfo
-SymbolizableObjectFile::symbolizeCode(object::SectionedAddress ModuleOffset,
-                                      FunctionNameKind FNKind,
-                                      bool UseSymbolTable) const {
+DILineInfo SymbolizableObjectFile::symbolizeCode(
+    object::SectionedAddress ModuleOffset, FunctionNameKind FNKind,
+    bool UseSymbolTable, bool UseSymbolTableForInlinedFunctions) const {
+  if (!UseSymbolTableForInlinedFunctions &&
+      shouldOverrideWithSymbolTable(FNKind, UseSymbolTable))
+    return symbolizeInlinedCode(ModuleOffset, FNKind, UseSymbolTable)
+        .getFrame(0);
+
   DILineInfo LineInfo;
 
   if (ModuleOffset.SectionIndex == object::SectionedAddress::UndefSection)
     ModuleOffset.SectionIndex =
         getModuleSectionIndexForAddress(ModuleOffset.Address);
 
   if (DebugInfoContext) {
     LineInfo = DebugInfoContext->getLineInfoForAddress(

lib/DebugInfo/Symbolize/Symbolize.cpp

LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
   if (!Info)
     return DILineInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
     ModuleOffset.Address += Info->getModulePreferredBase();
 
-  DILineInfo LineInfo = Info->symbolizeCode(ModuleOffset, Opts.PrintFunctions,
-                                            Opts.UseSymbolTable);
+  DILineInfo LineInfo = Info->symbolizeCode(
+      ModuleOffset, Opts.PrintFunctions, Opts.UseSymbolTable,
+      Opts.UseSymbolTableForInlinedFunctions);
   if (Opts.Demangle)
     LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
   return LineInfo;
 }
 
 Expected<DIInliningInfo>
 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName,
                                      object::SectionedAddress ModuleOffset,

test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           FileCheck
           LLVMHello
           UnitTests
           bugpoint
           count
           llc
           lli
           lli-child-target
+          llvm-addr2line
           llvm-ar
           llvm-as
           llvm-bcanalyzer
           llvm-c-test
           llvm-cat
           llvm-cfi-verify
           llvm-config
           llvm-cov

test/tools/llvm-symbolizer/addr2line.test

+# Should print the function name with '-f'.
+# Should print an inlined function name even with '-i=0' (the default)
+RUN: llvm-addr2line -fe %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+RUN:   | FileCheck %s --check-prefix=FUNCNAME
+FUNCNAME: inctwo
+
+# Should not print function name by default.
+RUN: llvm-addr2line -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+RUN:   | FileCheck %s --check-prefix=NOFUNCNAME
+NOFUNCNAME-NOT: inctwo
+
+# Should not print column number.
+RUN: llvm-addr2line -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+RUN:   | FileCheck %s --check-prefix=NOCOLUMN
+NOCOLUMN: {{^}}/tmp{{\\|/}}x.c:3{{$}}
+
+# Should not print inlined frames by default
+RUN: llvm-addr2line -f -p -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+RUN:   | FileCheck %s --check-prefix=NOINLINING
+NOINLINING-NOT: (inlined by)
 No newline at end of file

test/tools/llvm-symbolizer/demangle.s

 # RUN:    | FileCheck %s --check-prefix=MANGLED_FUNCTION_NAME
 # RUN: llvm-symbolizer -C --no-demangle --obj %t.o 0 \
 # RUN:    | FileCheck %s --check-prefix=MANGLED_FUNCTION_NAME
 # RUN: llvm-symbolizer --no-demangle --demangle --obj %t.o 0 \
 # RUN:    | FileCheck %s --check-prefix=DEMANGLED_FUNCTION_NAME
 # RUN: llvm-symbolizer --no-demangle -C --obj %t.o 0 \
 # RUN:    | FileCheck %s --check-prefix=DEMANGLED_FUNCTION_NAME
 
+# Check that for llvm-addr2line the default is not to demangle.
+# RUN: llvm-addr2line -fe %t.o 0 \
+# RUN:    | FileCheck %s --check-prefix=MANGLED_FUNCTION_NAME
+# RUN: llvm-addr2line -fCe %t.o 0 \
+# RUN:    | FileCheck %s --check-prefix=DEMANGLED_FUNCTION_NAME
+
 # MANGLED_FUNCTION_NAME: _Z1cv
 # DEMANGLED_FUNCTION_NAME: c()

tools/llvm-symbolizer/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-symbolizer
   llvm-symbolizer.cpp
   )
 
+add_llvm_tool_symlink(llvm-addr2line llvm-symbolizer)
+
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(addr2line llvm-symbolizer)
 endif()

tools/llvm-symbolizer/llvm-symbolizer.cpp

 
 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 (default)"),
+                          "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),

 // -obj, -exe, -e
 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::aliasopt(ClBinaryName));
-
+static cl::alias ClBinaryNameAliasE("e", cl::desc("Alias for -obj"),
+                                    cl::Grouping, cl::NotHidden,
+                                    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 "

 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::opt<DIPrinter::OutputStyle>
+    ClOutputStyle("output-style", cl::init(DIPrinter::OutputStyle::LLVM),
+                  cl::desc("Specify print style"), cl::Hidden,
+                  cl::values(clEnumValN(DIPrinter::OutputStyle::LLVM, "LLVM",
+                                        "LLVM default style"),
+                             clEnumValN(DIPrinter::OutputStyle::GNU, "GNU",
+                                        "GNU addr2line style")));
+
 template<typename T>
 static bool error(Expected<T> &ResOrErr) {
   if (ResOrErr)
     return false;
   logAllUnhandledErrors(ResOrErr.takeError(), errs(),
                         "LLVMSymbolizer: error reading file: ");
   return true;
 }
if (IsData) {
     auto ResOrErr = Symbolizer.symbolizeData(
         ModuleName, {Offset, object::SectionedAddress::UndefSection});
     Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get());
   } else if (ClPrintInlining) {
     auto ResOrErr = Symbolizer.symbolizeInlinedCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection},
         ClDwpName);
     Printer << (error(ResOrErr) ? DIInliningInfo() : ResOrErr.get());
   } else {
     auto ResOrErr = Symbolizer.symbolizeCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection},
         ClDwpName);
     Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get());
   }
   outs() << "\n";
   outs().flush();
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  bool IsAddr2Line = sys::path::stem(argv[0]).contains("addr2line");
+
+  if (IsAddr2Line) {
+    ClDemangle.setInitialValue(false);
+    ClPrintFunctions.setInitialValue(FunctionNameKind::None);
+    ClPrintInlining.setInitialValue(false);
+    ClOutputStyle.setInitialValue(DIPrinter::OutputStyle::GNU);
+  }
+
   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
-  cl::ParseCommandLineOptions(argc, argv, "llvm-symbolizer\n");
+  cl::ParseCommandLineOptions(
+      argc, argv, IsAddr2Line ? "llvm-addr2line\n" : "llvm-symbolizer\n");
 
   // If both --demangle and --no-demangle are specified then pick the last one.
   if (ClNoDemangle.getPosition() > ClDemangle.getPosition())
     ClDemangle = !ClNoDemangle;
 
   LLVMSymbolizer::Options Opts(ClPrintFunctions, ClUseSymbolTable, ClDemangle,
                                ClUseRelativeAddress, ClDefaultArch,
-                               ClFallbackDebugPath);
+                               ClFallbackDebugPath, !IsAddr2Line);
 
   for (const auto &hint : ClDsymHint) {
     if (sys::path::extension(hint) == ".dSYM") {
       Opts.DsymHints.push_back(hint);
     } else {
       errs() << "Warning: invalid dSYM hint: \"" << hint <<
                 "\" (must have the '.dSYM' extension).\n";
     }
   }
   LLVMSymbolizer Symbolizer(Opts);
 
   DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None,
                     ClPrettyPrint, ClPrintSourceContextLines, ClVerbose,
-                    ClBasenames);
+                    ClBasenames, ClOutputStyle);
 
   if (ClInputAddresses.empty()) {
     const int kMaxInputStringLength = 1024;
     char InputString[kMaxInputStringLength];
 
     while (fgets(InputString, sizeof(InputString), stdin))
       symbolizeInput(InputString, Symbolizer, Printer);
   } else {
     for (StringRef Address : ClInputAddresses)
       symbolizeInput(Address, Symbolizer, Printer);
   }
 
   return 0;
 }