[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 ↗

(On Diff #193076)

This should be the enum itself, not a bool

lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

230–231 ↗

(On Diff #193076)

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 ↗

(On Diff #193076)

nit: include a newline at the end

tools/llvm-symbolizer/llvm-symbolizer.cpp

274

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

[jhenderson]

test/tools/llvm-symbolizer/addr2line.test

1 ↗

(On Diff #193076)

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–100

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

149

Test cases for this new option?

266

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 ↗

(On Diff #193076)

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

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

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.

docs/CommandGuide/index.rst

.. toctree::
    llvm-objdump
    llvm-config
    llvm-cxxmap
    llvm-diff
    llvm-cov
    llvm-profdata
    llvm-stress
    llvm-symbolizer
+   llvm-addr2line
    llvm-dwarfdump
    dsymutil
    llvm-mca
 
 Debugging Tools
 ~~~~~~~~~~~~~~~
 
 .. toctree::

docs/CommandGuide/llvm-addr2line.rst

+llvm-addr2line - a drop-in replacement for addr2line
+====================================================
+
+SYNOPSIS
+--------
+
+:program:`llvm-addr2line` [options]
+
+DESCRIPTION
+-----------
+
+:program:`llvm-addr2line` is an alias for the
+:doc:`llvm-symbolizer <llvm-symbolizer>` tool with different defaults. The goal
+is to make it a drop-in replacement for GNU's :program:`addr2line`.
+
+Here are some of those differences:
+
+* Defaults not to print function names.
+
+  Use :ref:`-f <llvm-symbolizer-opt-f>` to enable that.
+
+* Defaults not to demangle function names.
+
+  Use :ref:`-C <llvm-symbolizer-opt-C>` to switch the demangling on.
+
+* Defaults not to print inlined frames.
+
+  Use :ref:`-i <llvm-symbolizer-opt-i>` to show inlined frames for a source code
+  location in an inlined function
+
+* Never overrides the name of an inlined function even if
+  :ref:`-use-symbol-table <llvm-symbolizer-opt-use-symbol-table>` is on.
+  For example:
+
+  .. code-block:: console
+
+    $ llvm-symbolizer -p -e=a.out 0x40054d
+    inc at /tmp/x.c:3:3
+     (inlined by) main at /tmp/x.c:9:0
+
+    $ llvm-symbolizer -p -i=0 -e=a.out 0x40054d
+    main at /tmp/x.c:3:3
+
+    $ llvm-symbolizer -p -i=0 -use-symbol-table=0 -e=a.out 0x40054d
+    inc at /tmp/x.c:3:3
+
+    $ llvm-addr2line -pfi -e=a.out 0x40054d
+    inc at /tmp/x.c:3
+     (inlined by) main at /tmp/x.c:9
+
+    $ llvm-addr2line -pf -use-symbol-table=0 -e=a.out 0x40054d
+    inc at /tmp/x.c:3
+
+    $ llvm-addr2line -pf -use-symbol-table=1 -e=a.out 0x40054d
+    inc at /tmp/x.c:3
+
+* Does not print column of a source code location
+
+SEE ALSO
+--------
+
+Refer to :doc:`llvm-symbolizer <llvm-symbolizer>` for additional information.

docs/CommandGuide/llvm-symbolizer.rst

 
 OPTIONS
 -------
 
 .. option:: -obj, -exe, -e
 
   Path to object file to be symbolized.
 
+.. _llvm-symbolizer-opt-f:
+
 .. 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``.
 
+.. _llvm-symbolizer-opt-use-symbol-table:
+
 .. option:: -use-symbol-table
 
  Prefer function names stored in symbol table to function names
  in debug info sections. Defaults to true.
 
+.. _llvm-symbolizer-opt-C:
+
 .. option:: -demangle, -C
 
  Print demangled function names. Defaults to true.
 
 .. option:: -no-demangle
 
  Don't print demangled function names.
 
+.. _llvm-symbolizer-opt-i:
+
 .. option:: -inlining, -inlines, -i
 
  If a source code location is in an inlined function, prints all the
  inlnied frames. Defaults to true.
 
 .. option:: -default-arch
 
  If a binary contains object files for multiple architectures (e.g. it is a

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/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()

test/tools/llvm-symbolizer/help.test

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

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

 RUN: llvm-symbolizer -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=LLVM
 
 RUN: llvm-symbolizer --output-style=GNU -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=GNU
 
 RUN: llvm-symbolizer --output-style=LLVM -e %p/Inputs/addr.exe 0x40054d \
 RUN:   | FileCheck %s --check-prefix=LLVM
 
+RUN: llvm-addr2line -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=GNU
+
+RUN: llvm-addr2line --output-style=GNU -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=GNU
+
+RUN: llvm-addr2line --output-style=LLVM -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=LLVM
+
 LLVM: {{^}}/tmp{{\\|/}}x.c:3:3{{$}}
 GNU: {{^}}/tmp{{\\|/}}x.c:3{{$}}

test/tools/llvm-symbolizer/sym.test

 RUN: llvm-symbolizer -inlining -print-address -p -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -inlines -print-address -pretty-print -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -inlines -print-address -p -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -i -print-address -pretty-print -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -i -print-address -p -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: echo "0x1" > %t.input
 RUN: llvm-symbolizer -obj=%p/Inputs/zero < %t.input | FileCheck -check-prefix="ZERO" %s
 
+RUN: llvm-addr2line -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix=A2L %s
+RUN: llvm-addr2line -a -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_A %s
+RUN: llvm-addr2line -f -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_F %s
+RUN: llvm-addr2line -i -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_I %s
+RUN: llvm-addr2line -fi -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_F,A2L_I,A2L_FI %s
+
+RUN: llvm-addr2line -pa -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_A %s
+RUN: llvm-addr2line -pf -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_F %s
+RUN: llvm-addr2line -paf -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_AF %s
+RUN: llvm-addr2line -pai -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_A,A2LP_I %s
+RUN: llvm-addr2line -pfi -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_F,A2LP_FI %s
+RUN: llvm-addr2line -pafi -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_AF,A2LP_FI %s
+
 #CHECK: some text
 #CHECK: 0x40054d
 #CHECK: main
 #CHECK: {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 #CHECK: some text2
 #
 #PRETTY: some text
 #PRETTY: {{[0x]+}}40054d: inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3:3
 #PRETTY:  (inlined by) inc at {{[/\]+}}tmp{{[/\]+}}x.c:7:0
 #PRETTY   (inlined by) main at {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 #PRETTY: some text2
 #
 #ZERO: ??
 #ZERO: ??:0:0
+#
+#A2L:         some text
+#A2L_A-NEXT:  0x40054d
+#A2L_F-NEXT:  inctwo
+#A2L-NEXT:    {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
+#A2L_FI-NEXT: inc{{$}}
+#A2L_I-NEXT:  {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
+#A2L_FI-NEXT: main
+#A2L_I-NEXT:  {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
+#A2L-NEXT:    some text2
+
+#A2LP:          some text
+#A2LP_A-NEXT:   0x40054d: {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
+#A2LP_F-NEXT:   inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
+#A2LP_AF-NEXT:  0x40054d: inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
+#A2LP_I-NEXT:   {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
+#A2LP_I-NEXT:   {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
+#A2LP_FI-NEXT:   (inlined by) inc at {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
+#A2LP_FI-NEXT:   (inlined by) main at {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
+#A2LP-NEXT:     some text2

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::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::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 parseCommand(StringRef InputString, bool &IsData,
   }
   // Skip delimiters and parse module offset.
   pos += strspn(pos, kDelimiters);
   int offset_length = strcspn(pos, kDelimiters);
   return !StringRef(pos, offset_length).getAsInteger(0, ModuleOffset);
 }
 
 static void symbolizeInput(StringRef InputString, LLVMSymbolizer &Symbolizer,
-                           DIPrinter &Printer) {
+                           DIPrinter &Printer, bool IsAddr2Line) {
   bool IsData = false;
   std::string ModuleName;
   uint64_t Offset = 0;
   if (!parseCommand(StringRef(InputString), IsData, ModuleName, Offset)) {
     outs() << InputString;
     return;
   }
 
   if (ClPrintAddress) {
     outs() << "0x";
     outs().write_hex(Offset);
     StringRef Delimiter = ClPrettyPrint ? ": " : "\n";
     outs() << Delimiter;
   }
   Offset -= ClAdjustVMA;
   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 if (IsAddr2Line) {
+    // With ClPrintFunctions == FunctionNameKind::LinkageName (default)
+    // and ClUseSymbolTable == 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},
+        ClDwpName);
+    Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get().getFrame(0));
   } else {
     auto ResOrErr = Symbolizer.symbolizeCode(
         ModuleName, {Offset, object::SectionedAddress::UndefSection},
         ClDwpName);
     Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get());
   }
+  if (!IsAddr2Line)
     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);
 
   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, ClOutputStyle);
 
   if (ClInputAddresses.empty()) {
     const int kMaxInputStringLength = 1024;
     char InputString[kMaxInputStringLength];
 
     while (fgets(InputString, sizeof(InputString), stdin))
-      symbolizeInput(InputString, Symbolizer, Printer);
+      symbolizeInput(InputString, Symbolizer, Printer, IsAddr2Line);
   } else {
     for (StringRef Address : ClInputAddresses)
-      symbolizeInput(Address, Symbolizer, Printer);
+      symbolizeInput(Address, Symbolizer, Printer, IsAddr2Line);
   }
 
   return 0;
 }