lld-link: Only print demangled symbol names by default

[thakis]

Summary

This makes lld-link's output a bit more concise. Since most developers can't read mangled names, this should make the output a bit easier to understand as well. It also makes lld-link's output consistent with ld.lld's output.

(link.exe prints both demangled and mangled names; lld-link used to match link.exe output but now no longer does.)

For people working on toolchains, add a /demangle:no flag that makes lld-link print the mangled name instead of the demangled name. (If desired, people could pipe that through demumble -b to get the old behavior of both demangled and mangled output.)

[ruiu]

It looks like always showing both mangled and demangled names makes the output a bit too large. I'm a little skeptical how useful it is. Where did you find it useful?

[smeenai]

In D58132#1395055, @ruiu wrote:

It looks like always showing both mangled and demangled names makes the output a bit too large. I'm a little skeptical how useful it is. Where did you find it useful?

I'm in favor of at least showing the mangled name. Part of the issue is that multiple symbols can have the same demangling (as mentioned in this commit's message), and the mangled name is also useful when you're trying to examine object files for references or definitions, etc.

[thakis]

In D58132#1395055, @ruiu wrote:

It looks like always showing both mangled and demangled names makes the output a bit too large. I'm a little skeptical how useful it is. Where did you find it useful?

I found the error message in comment 0 of https://bugs.chromium.org/p/chromium/issues/detail?id=930883 a bit difficult to read and wished I had the mangled symbol too. I'm used to the lld/coff output, I suppose. (It'd be nice if they were consistent in their output too.) The mangled name is usually shorter than the demangled one, so maybe it's not so bad. I agree output length is a concern though. I figured it's early in 9.0, we could land this and see if we like it, and if we don't, then remove it again (in both elf and coff). But in the end it's your call.

[pcc]

My personal opinion: 99% of the time I reckon users will want to see the demangled name (it's only us toolchain folks who might more often prefer the mangled names), and there's already a flag --no-demangle which can be used to suppress demangling if necessary. So I think I'd prefer making the COFF linker more like the ELF linker (i.e. don't show mangled names without a flag).

[smeenai]

In D58132#1396724, @pcc wrote:

My personal opinion: 99% of the time I reckon users will want to see the demangled name (it's only us toolchain folks who might more often prefer the mangled names), and there's already a flag --no-demangle which can be used to suppress demangling if necessary. So I think I'd prefer making the COFF linker more like the ELF linker (i.e. don't show mangled names without a flag).

I'd be happy with this (just demangled names being the default, as long as there's some way to either switch to or display mangled names in addition).

[thakis]

In D58132#1396724, @pcc wrote:

My personal opinion: 99% of the time I reckon users will want to see the demangled name (it's only us toolchain folks who might more often prefer the mangled names), and there's already a flag --no-demangle which can be used to suppress demangling if necessary. So I think I'd prefer making the COFF linker more like the ELF linker (i.e. don't show mangled names without a flag).

Makes sense.

I kind of like the "demangled" (mangled) output, but I suppose I can just make that a feature in demumble.

Does lld-link have a --no-demangle flag already? If not, any opinions on how it should be spelled?

[ruiu]

Boolean flags usually have the form /foo[:no] in MSVC linker, so I'd propose /demangle and /demangle:no for lld/coff.

[thakis]

Change lld-link instead.

[ruiu]

LGTM

lld/COFF/Symbols.cpp

19 ↗

(On Diff #190140)

Since this file is under COFF directory, it is more consistent to add using namespace lld::coff here instead of adding coff:: to Config.

lld/ELF/Symbols.cpp

void elf::maybeWarnUnorderableSymbol(const Symbol *Sym) {
   else if (D && !D->Section->Repl->Live)
     Warn(": unable to order discarded symbol: ");
 }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(B.getName()))
-      return *S;
+      return ("\"" + *S + "\" (" + B.getName() + ")").str();
   return B.getName();
 }

lld/test/ELF/conflict-variable-linkage-name.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld %t.o %t.o -o /dev/null 2>&1 | FileCheck %s
 
 ## Check we can report the locations of 2 different "bar" variables.
-# CHECK:      duplicate symbol: A::bar
+# CHECK:      duplicate symbol: "A::bar" (_ZN1A3barE)
 # CHECK-NEXT: >>> defined at 1.cpp:2
-# CHECK-NEXT: >>>            {{.*}}:(A::bar)
+# CHECK-NEXT: >>>            {{.*}}:("A::bar" (_ZN1A3barE))
 # CHECK-NEXT: >>> defined at 1.cpp:2
 # CHECK-NEXT: >>>            {{.*}}:(.bss+0x0)
-# CHECK:      duplicate symbol: Z::bar
+# CHECK:      duplicate symbol: "Z::bar" (_ZN1Z3barE)
 # CHECK-NEXT: >>> defined at 1.cpp:6
-# CHECK-NEXT: >>>            {{.*}}:(Z::bar)
+# CHECK-NEXT: >>>            {{.*}}:("Z::bar" (_ZN1Z3barE))
 # CHECK-NEXT: >>> defined at 1.cpp:6
 # CHECK-NEXT: >>>            {{.*}}:(.data+0x0)
 
 # Used reduced output from following code and clang version 7.0.0 (trunk 332701)
 # to produce this input file:
 # Source (1.cpp):
 #  namespace A {
 #    int bar;

lld/test/ELF/conflict.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: not ld.lld %t1.o %t1.o -o %t2 2>&1 | FileCheck -check-prefix=DEMANGLE %s
 
-# DEMANGLE:       duplicate symbol: mul(double, double)
+# DEMANGLE:       duplicate symbol: "mul(double, double)" (_Z3muldd)
 # DEMANGLE-NEXT:  >>> defined at {{.*}}:(.text+0x0)
 # DEMANGLE-NEXT:  >>> defined at {{.*}}:(.text+0x0)
 # DEMANGLE:       duplicate symbol: foo
 # DEMANGLE-NEXT:  >>> defined at {{.*}}:(.text+0x0)
 # DEMANGLE-NEXT:  >>> defined at {{.*}}:(.text+0x0)
 
 # RUN: not ld.lld %t1.o %t1.o -o %t2 --no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO_DEMANGLE %s

lld/test/ELF/debug-line-str.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -dwarf-version=5 %s -o %t.o
 # RUN: not ld.lld %t.o -o %t1 2>&1 | FileCheck %s
 
 # Check we do not crash and able to report the source location.
 
-# CHECK:      error: undefined symbol: foo()
+# CHECK:      error: undefined symbol: "foo()" (_Z3foov)
 # CHECK-NEXT: >>> referenced by test.cpp:3
 # CHECK-NEXT: >>>               {{.*}}.o:(.text+0x1)
 
 # The code below is the reduced version of the output
 # from the following invocation and source:
 #
 # // test.cpp:
 # int foo();

lld/test/ELF/linkerscript/map-file2.test

 # CHECK-NEXT:       1118             3108      109     1 .ddd
 # CHECK-NEXT:       1118             3108        1     1         BYTE ( 0x11 )
 # CHECK-NEXT:       1119             3109      100     1         . += 0x100
 # CHECK-NEXT:       1219             3209        8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.ddd)
 # CHECK-NEXT:       1228             3218       34     8 .eh_frame
 # CHECK-NEXT:       1228             3218       30     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.eh_frame+0x0)
 # CHECK-NEXT:       125c             324c        1     4 .text
 # CHECK-NEXT:       125c             324c        1     4         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.text)
-# CHECK-NEXT:       125c             324c        0     1                 f(int)
+# CHECK-NEXT:       125c             324c        0     1                 "f(int)" (_Z1fi)
 # CHECK-NEXT:       125c             324c        0     1                 _start
 # CHECK-NEXT:          0                0        8     1 .comment
 # CHECK-NEXT:          0                0        8     1         <internal>:(.comment)
 # CHECK-NEXT:          0                0       48     8 .symtab
 # CHECK-NEXT:          0                0       48     8         <internal>:(.symtab)
 # CHECK-NEXT:          0                0       48     1 .shstrtab
 # CHECK-NEXT:          0                0       48     1         <internal>:(.shstrtab)
 # CHECK-NEXT:          0                0        e     1 .strtab
 # CHECK-NEXT:          0                0        e     1         <internal>:(.strtab)

lld/test/ELF/map-file.s

 // CHECK-NEXT: 200300           200300       30     8         <internal>:(.rela.plt)
 // CHECK-NEXT: 200330           200330       64     8 .eh_frame
 // CHECK-NEXT: 200330           200330       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
 // CHECK-NEXT: 200360           200360       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
 // CHECK-NEXT: 200378           200378       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
 // CHECK-NEXT: 201000           201000       2d     4 .text
 // CHECK-NEXT: 201000           201000       28     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 201000           201000        0     1                 _start
-// CHECK-NEXT: 20101f           20101f        0     1                 f(int)
+// CHECK-NEXT: 20101f           20101f        0     1                 "f(int)" (_Z1fi)
 // CHECK-NEXT: 201028           201028        0     1                 local
 // CHECK-NEXT: 201028           201028        2     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
 // CHECK-NEXT: 201028           201028        0     1                 foo
 // CHECK-NEXT: 201029           201029        0     1                 bar
 // CHECK-NEXT: 20102a           20102a        0     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
 // CHECK-NEXT: 20102a           20102a        0     1                 zed
 // CHECK-NEXT: 20102c           20102c        0     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
 // CHECK-NEXT: 20102c           20102c        0     1                 bah

lld/test/ELF/undef.s

 # CHECK: error: undefined symbol: foo
 # CHECK: >>> referenced by undef.s
 # CHECK:                   {{.*}}:(.text+0x1)
 
 # CHECK: error: undefined symbol: bar
 # CHECK: >>> referenced by undef.s
 # CHECK: >>>               {{.*}}:(.text+0x6)
 
-# CHECK: error: undefined symbol: foo(int)
+# CHECK: error: undefined symbol: "foo(int)" (_Z3fooi)
 # CHECK: >>> referenced by undef.s
 # CHECK: >>>               {{.*}}:(.text+0x10)
 
-# CHECK: error: undefined symbol: vtable for Foo
+# CHECK: error: undefined symbol: "vtable for Foo" (_ZTV3Foo)
 # CHECK: the vtable symbol may be undefined because the class is missing its key function (see https://lld.llvm.org/missingkeyfunction)
 
 # CHECK: error: undefined symbol: zed2
 # CHECK: >>> referenced by {{.*}}.o:(.text+0x0) in archive {{.*}}2.a
 
 # CHECK: error: undefined symbol: zed3
 # CHECK: >>> referenced by undef-debug.s:3 (dir{{/|\\}}undef-debug.s:3)
 # CHECK: >>>               {{.*}}.o:(.text+0x0)