[llvm-nm] Add --line-numbers flag

[mysterymath]

Summary

This flag parallels the binutils flag of the same name. Debugging
information is loaded to print line number information for symbols, with
simlar semantics to llvm-symbolizer.

[mysterymath]

Add documentation.

[mysterymath]

Fix test on Windows.

[phosek]

LGTM but I'd wait a day or two before landing this so @jhenderson has a chance to respond.

llvm/tools/llvm-nm/llvm-nm.cpp

770

It'd be better if we could avoid instantiating LLVMSymbolizer unless needed since this is a non-trivial object. A simple way to do would be to move it to printLineNumbers and make it static but there might a cleaner way.

[jhenderson]

Sorry for the non-existent response up to now - I'm rather snowed under with review requests.

@MaskRay, any comments?

llvm/test/tools/llvm-nm/X86/line-numbers.test

2

Rather than using a canned object in this test, could you write a simple bit of code in assembly that has a few symbols and then use llvm-mc -g to assemble it with debug information? I would expect this to work for --line-numbers.

Canned object files are opaque and hard to maintain.

5

I'm not sure what this line is intended to be testing? Should that be an extern int e;?

I think it would be useful to have some comments explaining what each line is trying to test.

13

As well as an undefined data symbol, you might want an undefined function too.

llvm/tools/llvm-nm/llvm-nm.cpp

695

Test case?

700–701

Test case? I'm guessing this handles e.g. common or absolute symbols that don't have an associate section?

711–712

Test case?

714–715

Is this tested?

I believe you can have references to symbols from outside text sections after all (e.g. populating a variable with an address of a data symbol).

717–718

For this to be tested, you need at least two undefined symbols referenced via relocations in the same relocation section, but I don't see them, so I'm guessing it's not.

722

Why consumeError here rather than reporting the error? Same in various places below.

756

You need testing for symbols that don't end up with an associated file/line number (both defined and undefined).

770

std::optional<LLVMSymbolizer> which is initialised if LineNumbers is true, perhaps?

Nit: I don't think you need the llvm:: prefix here, right?

[MaskRay]

llvm/test/tools/llvm-nm/X86/line-numbers.test

13

e is not declared in this file. I agree that testing a function will be useful. Ideally, also test an undefined symbol that is not referenced (.globl und without a label definition gives an unreferenced undefined symbol)

21

Add -NEXT: whenever applicable.

By default the symbol list is sorted by name/size/addressed, so we don't need to worry about shuffled symbol table by llvm-mc updates.

llvm/tools/llvm-nm/llvm-nm.cpp

2486

This separates OPT_format_EQ and its values. Consider moving this immediately before NoLLVMBitcode

[MaskRay]

llvm/tools/llvm-nm/llvm-nm.cpp

734

We want test cases for a local symbol.

[mysterymath]

Address review feedback

[mysterymath]

Remove canned binary

[MaskRay]

llvm/test/tools/llvm-nm/X86/line-numbers.test

3

What does this check?

[jhenderson]

llvm/test/tools/llvm-nm/X86/line-numbers.test

28–42

It's not immediately clear to readers of this why you can't have some or all of these folded into main.s. It would be useful to have comments explaining a) exactly what each test case is trying to test that is different to other cases, and b) why they can't be part of main.s.

64

It would be clearer if there was a blank line between each input file.

llvm/tools/llvm-nm/llvm-nm.cpp

695

Although this is marked as done, it's not clear to me what test case is covering it. Could you please elaborate a bit more?

697

I'm not convinced there's any value in this local variable. In fact, the name SR is non-obvious as to its purpose or anything, and this function is somewhat long. I'd just get rid of the local variable entirely.

722

Now that you're reporting the error, there needs to be test cases for the error cases.

756

Although this is marked as done, I expected to see some test cases that had a mixture of "stuff found in the debug information" and "stuff not found in the debug information" to properly exercise this behaviour.

770

Nit: I don't think you need the llvm:: prefix here, right?

Still unaddressed?

[mysterymath]

Another round of comments

llvm/test/tools/llvm-nm/X86/line-numbers.test

3

Added a comment for this.

5

Yes; 'c' was a typo, it should have been 'e'. Regardless, I've renamed all these symbols to give an indication of why the symbol is part of the test case.

28–42

Added comments before each of these section for this.

llvm/tools/llvm-nm/llvm-nm.cpp

695

This is covered by the initial bitcode file test case; this is a symbolic file that is not an object file, so this dynamic cast fails.

697

This performs a cast; I've rewritten this to explicitly call the constructor to make this clearer. Renamed to Sym.

722

A test case that specifically targets this line encodes a proof that the line is reachable, but I don't have one, as these checks represent instead that there is no known proof that the case isn't reachable. Even if a proof of reachability or non-reachability were available, it would depend on encapsulated implementation details of Symbolizer and earlier portions of llvm-nm, and it shouldn't be baked into the behavior of printing line numbers, since that's logically independent from what kind of module validation has been done up until that point. Even if these cases aren't actually reachable (and thus fully untestable), there should still be checks here, since the reason they're not reachable is so contingent on other factors that should be free to change independently.

756

There is already some of this present in main.s, e.g., the absolute value case has no DWARF. I've added additional cases to main.s to show as many mixtures as are feasible using only the mechanisms available to llvm-mc. Handcrafting DWARF for the test case would make the abstraction level of the test mis-match the abstraction level of the implementation. The implementation is fully abstract over debugging formats, so ideally, it should be possible to update the test cases for such code without the ability to craft DWARF by hand.

770

Ah sorry.

[jhenderson]

llvm/test/tools/llvm-nm/X86/line-numbers.test

2–3

Nit: new tests in many of the LLVM tools use ## for comment markers, to help them stand out from the lit and FileCheck directives.

I don't understand how a "symbolic object file" is not already an "object file". This comment looks suspiciously like it's essentially copying code terms into the English prose, without actually stating what is significant. What is a "symbolic object file"? What is an "object file" in this context? Most importantly, how are the two different?

5

If you are trying to show that there is no output, it is better to do count 0 instead of a FileCheck command. However, I'm guessing that the output isn't expected to be empty. Showing that ":" is not in the output feels very fragile though - it could easily appear in a file path (if an absolute path is used on Windows, for example), or indeed other parts of the output. Better would be to match the output that is produced and use stuff like --implicit-check-not={{.}} to show that this is the entire output that is present.

--strict-whitespace also has no purpose in this particular test case.

9

It would make sense for this case to have a comment too, since all the others now do.

23

Can I suggest "... in the absence of any DWARF in the whole object, no line number ..." to clarify the distinction between this and the individual cases data_no_dwarf etc.

43–45

Nit: I'm confused what line wrapping rules you're following in this test file - compare this to the previous comment, and you'll note that one is not wrapped at all, whereas this one is broken up over three lines.

77

Same below.

llvm/tools/llvm-nm/llvm-nm.cpp

697

Could const SymbolRef Sym(S.Sym); be used? That seems clearer to me.

[mysterymath]

More review comments

llvm/test/tools/llvm-nm/X86/line-numbers.test

2–3

Yep, that's the case, but it's a good point that the tests should be readable while treating the implementation as a black box.

43–45

Yeah, my intent was to break comments along an 80 column boundary, but this was inconsistently applied.

llvm/tools/llvm-nm/llvm-nm.cpp

697

Yeah, that reads better to me too now that you mention it. Done.

[jhenderson]

LGTM. Probably should wait for @MaskRay too.

[MaskRay]

one nit

llvm/tools/llvm-nm/llvm-nm.cpp

763

[mysterymath]

Remove semicolon

llvm/docs/CommandGuide/llvm-nm.rst

 .. option:: --help, -h
 
  Print a summary of command-line options and their meanings.
 
 .. option:: -j
 
  Print just the symbol names. Alias for `--format=just-symbols``.
 
+.. option:: --line-numbers, -l
+
+ Use debugging information to print the filenames and line numbers where
+ symbols are defined. Undefined symbols have the location of their first
+ relocation printed instead.
+
 .. option:: -m
 
  Use Darwin format. Alias for ``--format=darwin``.
 
 .. option:: --no-demangle
 
  Don't demangle symbol names. This is the default.
 

llvm/docs/ReleaseNotes.rst

 Changes to the LLVM tools
 ---------------------------------
 
 * llvm-symbolizer now treats invalid input as an address for which source
   information is not found.
 * llvm-readelf now supports ``--extra-sym-info`` (``-X``) to display extra
   information (section name) when showing symbols.
 
+* ``llvm-nm`` now supports the ``--line-numbers`` (``-l``) option to use
+  debugging information to print symbols' filenames and line numbers.
+
 Changes to LLDB
 ---------------------------------
 
 * Methods in SBHostOS related to threads have had their implementations
   removed. These methods will return a value indicating failure.
 
 Changes to Sanitizers
 ---------------------

llvm/test/tools/llvm-nm/X86/line-numbers.test

+## Check that printing line numbers isn't attempted for files like bitcode,
+## which have symbols but limited/no section or debug info.
+# RUN: llvm-nm --line-numbers %p/Inputs/test.IRobj-x86_64 | FileCheck %s --check-prefix=BITCODE --match-full-lines --implicit-check-not={{.}}
+# BITCODE:      ---------------- S _global_const
+# BITCODE-NEXT: ---------------- D _global_data
+# BITCODE-NEXT: ---------------- T _global_func
+# BITCODE-NEXT: ---------------- S _hidden_const
+# BITCODE-NEXT: ---------------- D _hidden_data
+# BITCODE-NEXT: ---------------- T _hidden_func
+# BITCODE-NEXT: ---------------- s _static_const
+# BITCODE-NEXT: ---------------- d _static_data
+# BITCODE-NEXT: ---------------- t _static_func
+
+## Check that various symbol types can use debug information if available to
+## print line numbers, and if unavailable, don't print anything erroneous. The
+## specific cases checked are given by the symbol names below. Other test cases
+## place requirements on the contents of the whole file, so they are kept out
+## of main.o.
+# RUN: rm -rf %t
+# RUN: split-file %s %t
+# RUN: llvm-mc -g --filetype=obj %t/main.s -o %t/main.o
+# RUN: llvm-nm -l %t/main.o | FileCheck %s --match-full-lines --implicit-check-not={{.}}
+# RUN: llvm-nm --line-numbers %t/main.o | FileCheck %s --match-full-lines --implicit-check-not={{.}}
+
+# CHECK:      0000000000001234 a absolute_symbol
+# CHECK-NEXT: 0000000000000000 d data_no_dwarf
+# CHECK-NEXT: 0000000000000000 T defined_global_function [[FILENAME:.*main.s]]:4
+# CHECK-NEXT: 0000000000000001 t defined_local_function [[FILENAME]]:7
+# CHECK-NEXT: 0000000000000000 t function_no_dwarf
+# CHECK-NEXT:                  U undef1 [[FILENAME]]:12
+# CHECK-NEXT:                  U undef2 [[FILENAME]]:14
+# CHECK-NEXT:                  U undef_no_reloc
+# CHECK-NEXT: 0000000000000002 t undefined_references [[FILENAME]]:12
+
+## Check that in the absence of DWARF in the whole object, no line number
+## information is printed.
+# RUN: llvm-mc --filetype=obj %t/main.s -o %t/no-dwarf.o
+# RUN: llvm-nm -l %t/no-dwarf.o | FileCheck %s --check-prefix=NO-DWARF --match-full-lines --implicit-check-not={{.}}
+
+# NO-DWARF:      0000000000001234 a absolute_symbol
+# NO-DWARF-NEXT: 0000000000000000 d data_no_dwarf
+# NO-DWARF-NEXT: 0000000000000000 T defined_global_function
+# NO-DWARF-NEXT: 0000000000000001 t defined_local_function
+# NO-DWARF-NEXT: 0000000000000000 t function_no_dwarf
+# NO-DWARF-NEXT:                  U undef1
+# NO-DWARF-NEXT:                  U undef2
+# NO-DWARF-NEXT:                  U undef_no_reloc
+# NO-DWARF-NEXT: 0000000000000002 t undefined_references
+
+## Check that printing line numbers for undefined values is not attempted in
+## the absence of any relocation section.
+# RUN: llvm-mc --filetype=obj %t/undef-no-reloc-sections.s -o %t/undef-no-reloc-sections.o
+# RUN: llvm-nm --line-numbers %t/undef-no-reloc-sections.o | FileCheck %s --check-prefix=UNDEF-NO-RELOC-SECTIONS --match-full-lines --implicit-check-not={{.}}
+
+# UNDEF-NO-RELOC-SECTIONS: U undef
+
+## Check that printing line numbers for undefined values does not include
+## relocations for non-text sections. This is broken out of main.s to ensure
+## that the data relocation for undef comes first.
+# RUN: llvm-mc -g --filetype=obj %t/undef-data-reloc.s -o %t/undef-data-reloc.o
+# RUN: llvm-nm --line-numbers %t/undef-data-reloc.o | FileCheck %s --check-prefix=UNDEF-DATA-RELOC --match-full-lines --implicit-check-not={{.}}
+
+# UNDEF-DATA-RELOC:      0000000000000000 r data_reloc
+# UNDEF-DATA-RELOC-NEXT:                  U undef
+
+## Check that line numbers can be printed for data definitions. These are broken
+## out of main.s since their DWARF cannot be generated with llvm-mc -g.
+# RUN: llvm-mc -g --filetype=obj %t/data-dwarf.s -o %t/data-dwarf.o
+# RUN: llvm-nm --line-numbers %t/data-dwarf.o | FileCheck %s --check-prefix=DATA-DWARF --match-full-lines --implicit-check-not={{.}}
+
+# DATA-DWARF: 0000000000000000 D defined_data /tmp/tmp.c:1
+
+#--- main.s
+.text
+.globl defined_global_function
+defined_global_function:
+  ret
+
+defined_local_function:
+  ret
+
+absolute_symbol = 0x1234
+
+undefined_references:
+  nop
+  .long undef1
+  nop
+  .long undef2
+  ret
+
+# Note: llvm-mc -g produces no DWARF for data.
+.data
+data_no_dwarf:
+  .byte 0
+
+.globl undef_no_reloc
+
+# Note: llvm-mc -g does not produce DWARF for non-SHF_ALLOC sections.
+.section no_alloc_text,"x",@progbits
+function_no_dwarf:
+  ret
+
+#--- undef-no-reloc-sections.s
+.globl undef
+
+#--- undef-data-reloc.s
+.globl undef
+.rodata
+data_reloc:
+  .long undef
+
+#--- data-dwarf.s
+# char defined_data = 42
+  .text
+  .file "tmp.c"
+  .file 0 "/tmp" "/tmp/tmp.c" md5 0x39602a53b15a32d6a622ca86936e88d7
+  .file 1 "tmp.c" md5 0x39602a53b15a32d6a622ca86936e88d7
+  .type defined_data,@object            # @defined_data
+  .data
+  .globl  defined_data
+defined_data:
+  .byte 42                              # 0x2a
+  .size defined_data, 1
+
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                               # Abbreviation Code
+  .byte 17                              # DW_TAG_compile_unit
+  .byte 1                               # DW_CHILDREN_yes
+  .byte 37                              # DW_AT_producer
+  .byte 37                              # DW_FORM_strx1
+  .byte 19                              # DW_AT_language
+  .byte 5                               # DW_FORM_data2
+  .byte 3                               # DW_AT_name
+  .byte 37                              # DW_FORM_strx1
+  .byte 114                             # DW_AT_str_offsets_base
+  .byte 23                              # DW_FORM_sec_offset
+  .byte 16                              # DW_AT_stmt_list
+  .byte 23                              # DW_FORM_sec_offset
+  .byte 27                              # DW_AT_comp_dir
+  .byte 37                              # DW_FORM_strx1
+  .byte 115                             # DW_AT_addr_base
+  .byte 23                              # DW_FORM_sec_offset
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
+  .byte 2                               # Abbreviation Code
+  .byte 52                              # DW_TAG_variable
+  .byte 0                               # DW_CHILDREN_no
+  .byte 3                               # DW_AT_name
+  .byte 37                              # DW_FORM_strx1
+  .byte 73                              # DW_AT_type
+  .byte 19                              # DW_FORM_ref4
+  .byte 63                              # DW_AT_external
+  .byte 25                              # DW_FORM_flag_present
+  .byte 58                              # DW_AT_decl_file
+  .byte 11                              # DW_FORM_data1
+  .byte 59                              # DW_AT_decl_line
+  .byte 11                              # DW_FORM_data1
+  .byte 2                               # DW_AT_location
+  .byte 24                              # DW_FORM_exprloc
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
+  .byte 3                               # Abbreviation Code
+  .byte 36                              # DW_TAG_base_type
+  .byte 0                               # DW_CHILDREN_no
+  .byte 3                               # DW_AT_name
+  .byte 37                              # DW_FORM_strx1
+  .byte 62                              # DW_AT_encoding
+  .byte 11                              # DW_FORM_data1
+  .byte 11                              # DW_AT_byte_size
+  .byte 11                              # DW_FORM_data1
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
+  .byte 0                               # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  5                               # DWARF version number
+  .byte 1                               # DWARF Unit Type
+  .byte 8                               # Address Size (in bytes)
+  .long .debug_abbrev                   # Offset Into Abbrev. Section
+  .byte 1                               # Abbrev [1] 0xc:0x22 DW_TAG_compile_unit
+  .byte 0                               # DW_AT_producer
+  .short  12                              # DW_AT_language
+  .byte 1                               # DW_AT_name
+  .long .Lstr_offsets_base0             # DW_AT_str_offsets_base
+  .long .Lline_table_start0             # DW_AT_stmt_list
+  .byte 2                               # DW_AT_comp_dir
+  .long .Laddr_table_base0              # DW_AT_addr_base
+  .byte 2                               # Abbrev [2] 0x1e:0xb DW_TAG_variable
+  .byte 3                               # DW_AT_name
+  .long 41                              # DW_AT_type
+                                        # DW_AT_external
+  .byte 1                               # DW_AT_decl_file
+  .byte 1                               # DW_AT_decl_line
+  .byte 2                               # DW_AT_location
+  .byte 161
+  .byte 0
+  .byte 3                               # Abbrev [3] 0x29:0x4 DW_TAG_base_type
+  .byte 4                               # DW_AT_name
+  .byte 6                               # DW_AT_encoding
+  .byte 1                               # DW_AT_byte_size
+  .byte 0                               # End Of Children Mark
+.Ldebug_info_end0:
+  .section  .debug_str_offsets,"",@progbits
+  .long 24                              # Length of String Offsets Set
+  .short  5
+  .short  0
+.Lstr_offsets_base0:
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "Debian clang version 14.0.6"   # string offset=0
+.Linfo_string1:
+  .asciz  "/tmp/tmp.c"                    # string offset=28
+.Linfo_string2:
+  .asciz  "/tmp"                          # string offset=39
+.Linfo_string3:
+  .asciz  "defined_data"                  # string offset=44
+.Linfo_string4:
+  .asciz  "char"                          # string offset=57
+  .section  .debug_str_offsets,"",@progbits
+  .long .Linfo_string0
+  .long .Linfo_string1
+  .long .Linfo_string2
+  .long .Linfo_string3
+  .long .Linfo_string4
+  .section  .debug_addr,"",@progbits
+  .long .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
+.Ldebug_addr_start0:
+  .short  5                               # DWARF version number
+  .byte 8                               # Address size
+  .byte 0                               # Segment selector size
+.Laddr_table_base0:
+  .quad defined_data
+.Ldebug_addr_end0:
+  .ident  "Debian clang version 14.0.6"
+  .section  ".note.GNU-stack","",@progbits
+  .addrsig
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

llvm/tools/llvm-nm/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsInfos
   BinaryFormat
   Core
   Demangle
   Object
   Option
   Support
+  Symbolize
   TargetParser
   TextAPI
   )
 
 set(LLVM_TARGET_DEFINITIONS Opts.td)
 tablegen(LLVM Opts.inc -gen-opt-parser-defs)
 add_public_tablegen_target(NmOptsTableGen)
 

llvm/tools/llvm-nm/Opts.td

 def debug_syms : FF<"debug-syms", "Show all symbols, even debugger only">;
 def defined_only : FF<"defined-only", "Show only defined symbols">;
 defm demangle : BB<"demangle", "Demangle C++ symbol names", "Don't demangle symbol names">;
 def dynamic : FF<"dynamic", "Display dynamic symbols instead of normal symbols">;
 def export_symbols : FF<"export-symbols", "Export symbol list for all inputs">;
 def extern_only : FF<"extern-only", "Show only external symbols">;
 defm format : Eq<"format", "Specify output format: bsd (default), posix, sysv, darwin, just-symbols">, MetaVarName<"<format>">;
 def help : FF<"help", "Display this help">;
+def line_numbers : FF<"line-numbers", "Use debugging information to print symbols' filenames and line numbers">;
 def no_llvm_bc : FF<"no-llvm-bc", "Disable LLVM bitcode reader">;
 def no_sort : FF<"no-sort", "Show symbols in order encountered">;
 def no_weak : FF<"no-weak", "Show only non-weak symbols">;
 def numeric_sort : FF<"numeric-sort", "Sort symbols by address">;
 def print_armap : FF<"print-armap", "Print the archive map">;
 def print_file_name : FF<"print-file-name", "Precede each symbol with the object file it came from">;
 def print_size : FF<"print-size", "Show symbol size as well as address">;
 def quiet : FF<"quiet", "Suppress 'no symbols' diagnostic">;

 def : F<"A", "Alias for --print-file-name">, Alias<print_file_name>;
 def : F<"B", "Alias for --format=bsd">, Alias<format_EQ>, AliasArgs<["bsd"]>;
 def : F<"C", "Alias for --demangle">, Alias<demangle>;
 def : F<"D", "Alias for --dynamic">, Alias<dynamic>;
 def : JoinedOrSeparate<["-"], "f">, HelpText<"Alias for --format">, Alias<format_EQ>, MetaVarName<"<format>">;
 def : F<"h", "Alias for --help">, Alias<help>;
 def : F<"g", "Alias for --extern-only">, Alias<extern_only>;
 def : F<"j", "Alias for --format=just-symbols">, Alias<format_EQ>, AliasArgs<["just-symbols"]>;
+def : F<"l", "Alias for --line-numbers">, Alias<line_numbers>;
 def : F<"m", "Alias for --format=darwin">, Alias<format_EQ>, AliasArgs<["darwin"]>;
 def : F<"M", "Deprecated alias for --print-armap">, Alias<print_armap>, Flags<[HelpHidden]>;
 def : F<"n", "Alias for --numeric-sort">, Alias<numeric_sort>;
 def : F<"o", "Alias for --print-file-name">, Alias<print_file_name>;
 def : F<"p", "Alias for --no-sort">, Alias<no_sort>;
 def : F<"P", "Alias for --format=posix">, Alias<format_EQ>, AliasArgs<["posix"]>;
 def : F<"r", "Alias for --reverse-sort">, Alias<reverse_sort>;
 def : F<"S", "Alias for --print-size">, Alias<print_size>;
 def : JoinedOrSeparate<["-"], "t">, HelpText<"Alias for --radix">, Alias<radix_EQ>, MetaVarName<"<radix>">;
 def : F<"u", "Alias for --undefined-only">, Alias<undefined_only>;
 def : F<"U", "Alias for --defined-only">, Alias<defined_only>;
 def : F<"v", "Alias for --numeric-sort">, Alias<numeric_sort>;
 def : F<"V", "Alias for --version">, Alias<version>;
 def : F<"W", "Alias for --no-weak">, Alias<no_weak>;

llvm/tools/llvm-nm/llvm-nm.cpp

 // output formats.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"

 static bool ArchiveMap;
 static BitModeTy BitMode;
 static bool DebugSyms;
 static bool DefinedOnly;
 static bool Demangle;
 static bool DynamicSyms;
 static bool ExportSymbols;
 static bool ExternalOnly;
+static bool LineNumbers;
 static OutputFormatTy OutputFormat;
 static bool NoLLVMBitcode;
 static bool NoSort;
 static bool NoWeakSymbols;
 static bool NumericSort;
 static bool PrintFileName;
 static bool PrintSize;
 static bool Quiet;
if (LibraryOrdinal != 0) {
         if (!MachO ||
             MachO->getLibraryShortNameByIndex(LibraryOrdinal - 1, LibraryName))
           outs() << " (from bad library ordinal " << LibraryOrdinal << ")";
         else
           outs() << " (from " << LibraryName << ")";
       }
     }
   }
-
-  outs() << "\n";
 }
 
 // Table that maps Darwin's Mach-O stab constants to strings to allow printing.
 struct DarwinStabName {
   uint8_t NType;
   const char *Name;
 };
 const struct DarwinStabName DarwinStabNames[] = {
static void printExportSymbolList(const std::vector<NMSymbol> &SymbolList) {
   for (const NMSymbol &Sym : SymbolList) {
     outs() << Sym.Name;
     if (!Sym.Visibility.empty())
       outs() << ' ' << Sym.Visibility;
     outs() << '\n';
   }
 }
 
+static void printLineNumbers(symbolize::LLVMSymbolizer &Symbolizer,
+                             const NMSymbol &S) {
+  const auto *Obj = dyn_cast<ObjectFile>(S.Sym.getObject());
+  if (!Obj)
+    return;
+  const SymbolRef Sym(S.Sym);
+  uint64_t SectionIndex = object::SectionedAddress::UndefSection;
+  section_iterator Sec = cantFail(Sym.getSection());
+  if (Sec != Obj->section_end())
+    SectionIndex = Sec->getIndex();
+  object::SectionedAddress Address = {cantFail(Sym.getAddress()), SectionIndex};
+
+  std::string FileName;
+  uint32_t Line;
+  switch (S.TypeChar) {
+  // For undefined symbols, find the first relocation for that symbol with a
+  // line number.
+  case 'U': {
+    for (const SectionRef RelocsSec : Obj->sections()) {
+      if (RelocsSec.relocations().empty())
+        continue;
+      SectionRef TextSec = *cantFail(RelocsSec.getRelocatedSection());
+      if (!TextSec.isText())
+        continue;
+      for (const RelocationRef R : RelocsSec.relocations()) {
+        if (R.getSymbol() != Sym)
+          continue;
+        Expected<DILineInfo> ResOrErr = Symbolizer.symbolizeCode(
+            *Obj, {TextSec.getAddress() + R.getOffset(), SectionIndex});
+        if (!ResOrErr) {
+          error(ResOrErr.takeError(), Obj->getFileName());
+          return;
+        }
+        if (ResOrErr->FileName == DILineInfo::BadString)
+          return;
+        FileName = std::move(ResOrErr->FileName);
+        Line = ResOrErr->Line;
+        break;
+      }
+      if (!FileName.empty())
+        break;
+    }
+    if (FileName.empty())
+      return;
+    break;
+  }
+  case 't':
+  case 'T': {
+    Expected<DILineInfo> ResOrErr = Symbolizer.symbolizeCode(*Obj, Address);
+    if (!ResOrErr) {
+      error(ResOrErr.takeError(), Obj->getFileName());
+      return;
+    }
+    if (ResOrErr->FileName == DILineInfo::BadString)
+      return;
+    FileName = std::move(ResOrErr->FileName);
+    Line = ResOrErr->Line;
+    break;
+  }
+  default: {
+    Expected<DIGlobal> ResOrErr = Symbolizer.symbolizeData(*Obj, Address);
+    if (!ResOrErr) {
+      error(ResOrErr.takeError(), Obj->getFileName());
+      return;
+    }
+    if (ResOrErr->DeclFile.empty())
+      return;
+    FileName = std::move(ResOrErr->DeclFile);
+    Line = ResOrErr->DeclLine;
+    break;
+  }
+  }
+  outs() << '\t' << FileName << ':' << Line;
+}
+
 static void printSymbolList(SymbolicFile &Obj,
                             std::vector<NMSymbol> &SymbolList, bool printName,
                             StringRef ArchiveName, StringRef ArchitectureName) {
+  std::optional<symbolize::LLVMSymbolizer> Symbolizer;
+  if (LineNumbers)
+    Symbolizer.emplace();
+
   if (!PrintFileName) {
     if ((OutputFormat == bsd || OutputFormat == posix ||
          OutputFormat == just_symbols) &&
         MultipleFiles && printName) {
       outs() << '\n' << CurrentFilename << ":\n";
     } else if (OutputFormat == sysv) {
       outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n";
       if (Obj.is64Bit())
for (const NMSymbol &S : SymbolList) {
     // nm(1) -m output or hex, else if OutputFormat is darwin or we are
     // printing Mach-O symbols in hex and not a Mach-O object fall back to
     // OutputFormat bsd (see below).
     if ((OutputFormat == darwin || FormatMachOasHex) && (MachO || Obj.isIR())) {
       darwinPrintSymbol(Obj, S, SymbolAddrStr, printBlanks, printDashes,
                         printFormat);
     } else if (OutputFormat == posix) {
       outs() << Name << " " << S.TypeChar << " " << SymbolAddrStr << " "
-             << (MachO ? "0" : SymbolSizeStr) << "\n";
+             << (MachO ? "0" : SymbolSizeStr);
     } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) {
       if (PrintAddress)
         outs() << SymbolAddrStr << ' ';
       if (PrintSize)
         outs() << SymbolSizeStr << ' ';
       outs() << S.TypeChar;
       if (S.TypeChar == '-' && MachO)
         darwinPrintStab(MachO, S);
       outs() << " " << Name;
       if (S.TypeChar == 'I' && MachO) {
         outs() << " (indirect for ";
         if (S.Sym.getRawDataRefImpl().p) {
           StringRef IndirectName;
           if (MachO->getIndirectName(S.Sym.getRawDataRefImpl(), IndirectName))
             outs() << "?)";
           else
             outs() << IndirectName << ")";
         } else
           outs() << S.IndirectName << ")";
       }
-      outs() << "\n";
     } else if (OutputFormat == sysv) {
       outs() << left_justify(Name, 20) << "|" << SymbolAddrStr << "|   "
              << S.TypeChar << "  |" << right_justify(S.TypeName, 18) << "|"
-             << SymbolSizeStr << "|     |" << S.SectionName << "\n";
+             << SymbolSizeStr << "|     |" << S.SectionName;
     }
+    if (LineNumbers)
+      printLineNumbers(*Symbolizer, S);
+    outs() << '\n';
   }
 
   SymbolList.clear();
 }
 
 static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,
                                 basic_symbol_iterator I) {
   // OK, this is ELF
int llvm_nm_main(int argc, char **argv, const llvm::ToolContext &) {
   }
 
   DebugSyms = Args.hasArg(OPT_debug_syms);
   DefinedOnly = Args.hasArg(OPT_defined_only);
   Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, false);
   DynamicSyms = Args.hasArg(OPT_dynamic);
   ExternalOnly = Args.hasArg(OPT_extern_only);
   StringRef V = Args.getLastArgValue(OPT_format_EQ, "bsd");
   if (V == "bsd")
     OutputFormat = bsd;
   else if (V == "posix")
     OutputFormat = posix;
   else if (V == "sysv")
     OutputFormat = sysv;
   else if (V == "darwin")
     OutputFormat = darwin;
   else if (V == "just-symbols")
     OutputFormat = just_symbols;
   else
     error("--format value should be one of: bsd, posix, sysv, darwin, "
           "just-symbols");
+  LineNumbers = Args.hasArg(OPT_line_numbers);
   NoLLVMBitcode = Args.hasArg(OPT_no_llvm_bc);
   NoSort = Args.hasArg(OPT_no_sort);
   NoWeakSymbols = Args.hasArg(OPT_no_weak);
   NumericSort = Args.hasArg(OPT_numeric_sort);
   ArchiveMap = Args.hasArg(OPT_print_armap);
   PrintFileName = Args.hasArg(OPT_print_file_name);
   PrintSize = Args.hasArg(OPT_print_size);
   ReverseSort = Args.hasArg(OPT_reverse_sort);