[llvm-objdump] --syms: make flags closer to GNU objdump

[MaskRay]

Summary

This fixes several issues. The behavior changes are:

A SHN_COMMON symbol does not have the 'g' flag.
An undefined symbol does not have 'g' or 'l' flag.
A STB_GLOBAL SymbolRef::ST_Unknown symbol has the 'g' flag.
A STB_LOCAL SymbolRef::ST_Unknown symbol has the 'l' flag.

There are 30+ other lld tests need fixing.

[grimar]

It looks fine, I confirm I observe the same behavior with "GNU objdump (GNU Binutils for Ubuntu) 2.31.1".

There are 30+ other lld tests need fixing.

I think you can continue with this, perhaps worth to wait for a second opinion just in case.

lld/test/ELF/arm-target1.s

 
 .text
   .word patatino(target1)
   patatino:
         .word 32
 // Force generation of $d.0 as section is not all data
   nop
 // RELATIVE: SYMBOL TABLE:
-// RELATIVE: 00001154         .text           00000000 patatino
+// RELATIVE: 00001154 l       .text           00000000 patatino
 // RELATIVE: Disassembly of section .text:
 // RELATIVE-EMPTY:
 // RELATIVE: $d.0:
 // RELATIVE:     1150:       04 00 00 00     .word   0x00000004
 
 // ABS: can't create dynamic relocation R_ARM_TARGET1 against symbol: patatino in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
 // ABS: >>> defined in {{.*}}.o
 // ABS: >>> referenced by {{.*}}.o:(.text+0x0)

lld/test/ELF/edata-etext.s

 ## 4) Addresses of _edata == edata, _end == end and _etext == etext.
 # CHECK:      Sections:
 # CHECK-NEXT:  Idx Name          Size     VMA              Type
 # CHECK-NEXT:    0               00000000 0000000000000000
 # CHECK-NEXT:    1 .text         00000001 0000000000201158 TEXT
 # CHECK-NEXT:    2 .data         00000002 0000000000202159 DATA
 # CHECK-NEXT:    3 .bss          00000006 000000000020215c BSS
 # CHECK:      SYMBOL TABLE:
-# CHECK-NEXT:  000000000020215b         .data 0000000000000000 _edata
-# CHECK-NEXT:  0000000000202162         .bss  0000000000000000 _end
-# CHECK-NEXT:  0000000000201159         .text 0000000000000000 _etext
-# CHECK-NEXT:  0000000000201158         .text 0000000000000000 _start
-# CHECK-NEXT:  000000000020215b         .data 0000000000000000 edata
-# CHECK-NEXT:  0000000000202162         .bss  0000000000000000 end
-# CHECK-NEXT:  0000000000201159         .text 0000000000000000 etext
+# CHECK-NEXT:  000000000020215b g       .data 0000000000000000 _edata
+# CHECK-NEXT:  0000000000202162 g       .bss  0000000000000000 _end
+# CHECK-NEXT:  0000000000201159 g       .text 0000000000000000 _etext
+# CHECK-NEXT:  0000000000201158 g       .text 0000000000000000 _start
+# CHECK-NEXT:  000000000020215b g       .data 0000000000000000 edata
+# CHECK-NEXT:  0000000000202162 g       .bss  0000000000000000 end
+# CHECK-NEXT:  0000000000201159 g       .text 0000000000000000 etext
 
 # RUN: ld.lld -r %t.o -o %t2
 # RUN: llvm-objdump -t %t2 | FileCheck %s --check-prefix=RELOCATABLE
 # RELOCATABLE:       0000000000000000 *UND* 0000000000000000 _edata
 # RELOCATABLE-NEXT:  0000000000000000 *UND* 0000000000000000 _end
 # RELOCATABLE-NEXT:  0000000000000000 *UND* 0000000000000000 _etext
 
 .global _start,_end,_etext,_edata,end,etext,edata
 .text
 _start:
   nop
 .data
   .word 1
 .bss
   .align 4
   .space 6

lld/test/ELF/edata-no-bss.s

 # REQUIRES: x86
 
 ## _edata points to the end of the last mapped initialized section.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t --gc-sections
 # RUN: llvm-objdump -t -section-headers %t | FileCheck %s
 
 # CHECK: .data         00000008 000000000020215c DATA
 
-# CHECK: 0000000000202164         .data  0000000000000000 _edata
+# CHECK: 0000000000202164 g       .data  0000000000000000 _edata
 
 .text
 .globl _start
 _start:
 .long .data - .
 
 .data
 .quad 0
 
 .globl _edata

llvm/test/MC/AArch64/inst-directive.s

 // CHECK-ASM:        .inst   0x5e104020
 
 // CHECK-OBJ: Section {
 // CHECK-OBJ:   Name: .inst.aarch64_inst
 // CHECK-OBJ:   SectionData (
 // CHECK-OBJ-NEXT: 0000: 2040105E
 // CHECK-OBJ-NEXT: )
 
-// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d
-// CHECK-SYMS:     0000000000000000 .inst.aarch64_inst 0000000000000000 $x
-// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d
+// CHECK-SYMS-NOT: 0000000000000000 l .inst.aarch64_inst 0000000000000000 $d
+// CHECK-SYMS:     0000000000000000 l .inst.aarch64_inst 0000000000000000 $x
+// CHECK-SYMS-NOT: 0000000000000000 l .inst.aarch64_inst 0000000000000000 $d

llvm/test/MC/AArch64/mapping-across-sections.s

// Changing back to .text should not emit a redundant $x
         add w0, w0, w0
 
 // With all those constraints, we want:
 //   + .text to have $x at 0 and no others
 //   + .wibble to have $x at 0
 //   + .starts_data to have $d at 0
 
 
-// CHECK:      0000000000000000 .starts_data 0000000000000000 $d
-// CHECK-NEXT: 0000000000000000 .text        0000000000000000 $x
-// CHECK-NEXT: 0000000000000000 .wibble      0000000000000000 $x
+// CHECK:      0000000000000000 l .starts_data 0000000000000000 $d
+// CHECK-NEXT: 0000000000000000 l .text        0000000000000000 $x
+// CHECK-NEXT: 0000000000000000 l .wibble      0000000000000000 $x
 // CHECK-NOT: ${{[adtx]}}
 

llvm/test/MC/ARM/mapping-initial.s

 @ RUN: llvm-mc -triple=armv7a-none-eabi     -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM
 @ RUN: llvm-mc -triple=armebv7a-none-eabi   -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM
 @ RUN: llvm-mc -triple=thumbv7a-none-eabi   -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB
 @ RUN: llvm-mc -triple=thumbebv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB
 
   add r0, r0, r0
 
-@ ARM:      00000000         .text  00000000 $a
-@ THUMB:    00000000         .text  00000000 $t
+@ ARM:      00000000 l       .text  00000000 $a
+@ THUMB:    00000000 l       .text  00000000 $t

llvm/test/MC/ARM/mapping-within-section.s

@ $d at 0x0012
     .ascii "012"
     .byte 1
     .byte 2
     .byte 3
 @ $a at 0x0018
     .arm
     add r0, r0, r0
 
-@ CHECK:      00000000         .text  00000000 $a
-@ CHECK-NEXT: 0000000c         .text  00000000 $a
-@ CHECK-NEXT: 00000018         .text  00000000 $a
-@ CHECK-NEXT: 00000004         .text  00000000 $d
-@ CHECK-NEXT: 00000012         .text  00000000 $d
-@ CHECK-NEXT: 00000008         .text  00000000 $t
-@ CHECK-NEXT: 00000010         .text  00000000 $t
+@ CHECK:      00000000 l       .text  00000000 $a
+@ CHECK-NEXT: 0000000c l       .text  00000000 $a
+@ CHECK-NEXT: 00000018 l       .text  00000000 $a
+@ CHECK-NEXT: 00000004 l       .text  00000000 $d
+@ CHECK-NEXT: 00000012 l       .text  00000000 $d
+@ CHECK-NEXT: 00000008 l       .text  00000000 $t
+@ CHECK-NEXT: 00000010 l       .text  00000000 $t

llvm/test/MC/ARM/multi-section-mapping.s

@ cause $d to appear in the .text section
         .word 0
 
 @ With all those constraints, we want:
 @   + .text to have $a at 0, $t at 8, $d at 12
 @   + .wibble to have $a at 0
 @   + .starts_thumb to have $t at 0
 @   + .starts_data to have $d at 0
 
-@ CHECK: 00000000 .text 00000000 $a
-@ CHECK-NEXT: 00000000 .wibble 00000000 $a
-@ CHECK-NEXT: 0000000a .text 00000000 $d
-@ CHECK-NEXT: 00000000 .starts_thumb 00000000 $t
-@ CHECK-NEXT: 00000008 .text 00000000 $t
+@ CHECK: 00000000 l .text 00000000 $a
+@ CHECK-NEXT: 00000000 l .wibble 00000000 $a
+@ CHECK-NEXT: 0000000a l .text 00000000 $d
+@ CHECK-NEXT: 00000000 l .starts_thumb 00000000 $t
+@ CHECK-NEXT: 00000008 l .text 00000000 $t
 @ CHECK-NOT: ${{[adt]}}
 

llvm/test/MC/ARM/relocated-mapping.s

 @ RUN: llvm-mc -triple=arm-linux-gnueabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s
 
 @ Implementation-detail test (unfortunately): values that are relocated do not
 @ go via MCStreamer::EmitBytes; make sure they still emit a mapping symbol.
         add r0, r0, r0
         .word somewhere
         add r0, r0, r0
 
-@ CHECK: 00000000 .text 00000000 $a
-@ CHECK-NEXT: 00000008 .text 00000000 $a
-@ CHECK-NEXT: 00000004 .text 00000000 $d
+@ CHECK: 00000000 l .text 00000000 $a
+@ CHECK-NEXT: 00000008 l .text 00000000 $a
+@ CHECK-NEXT: 00000004 l .text 00000000 $d

llvm/test/MC/AsmParser/defsym.s

 .ifndef b
 .err
 .endif
 
 .if b<>11
 .err
 .endif
 
-# CHECK: 00000007         *ABS*  00000000 a
-# CHECK: 0000000b         *ABS*  00000000 b
+# CHECK: 00000007 l       *ABS*  00000000 a
+# CHECK: 0000000b l       *ABS*  00000000 b
 

llvm/test/MC/Hexagon/common-redeclare.s

 # RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s
 
-# CHECK: 00000062 g     O *COM*           00000008 quartet_table_isqrt
+# CHECK: 00000062       O *COM*           00000008 quartet_table_isqrt
 
 .common quartet_table_isqrt, 98, 8
 .common quartet_table_isqrt, 98, 8

llvm/test/MC/Hexagon/offset.s

 # RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s
 #
 
 sym_a:
 .set sym_d, sym_a + 8
-# CHECK: 00000000         .text 00000000 sym_a
-# CHECK: 00000008         .text 00000000 sym_d
+# CHECK: 00000000 l       .text 00000000 sym_a
+# CHECK: 00000008 l       .text 00000000 sym_d

llvm/test/tools/llvm-objdump/WebAssembly/symbol-table.test

 RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
 
 CHECK:      SYMBOL TABLE:
 CHECK-NEXT: 00000001 g     F CODE main
 CHECK-NEXT: 00000000 l     O DATA .L.str
-CHECK-NEXT: 00000000 g     F *UND*  puts
+CHECK-NEXT: 00000000       F *UND*  puts
 CHECK-NEXT: 00000019 l     F CODE .LSomeOtherFunction_bitcast
-CHECK-NEXT: 00000000 g     F *UND*  SomeOtherFunction
+CHECK-NEXT: 00000000       F *UND*  SomeOtherFunction
 CHECK-NEXT: 00000010 g     O DATA var

llvm/test/tools/llvm-objdump/X86/adjust-vma.test

 # ADJUST-NEXT:    4 .data           00000004 0000000000123000 DATA
 # ADJUST-NEXT:    5 .rela.data      00000018 0000000000000000
 # ADJUST-NEXT:    6 .symtab         00000060 0000000000000000
 # ADJUST-NEXT:    7 .strtab         00000010 0000000000000000
 # ADJUST-NEXT:    8 .shstrtab       0000003c 0000000000000000
 
 # COMMON:      SYMBOL TABLE:
 # COMMON-NEXT:  0000000000000001  l F .text 0000000000000000 func
-# COMMON-NEXT:  0000000000000000      .text 0000000000000000 sym
+# COMMON-NEXT:  0000000000000000  l   .text 0000000000000000 sym
 # COMMON-NEXT:  0000000000000000  l d .text 0000000000000000 .text
 
 # NOADJUST:      0000000000000000 sym:
 # NOADJUST-NEXT:   0: {{.*}}  nop
 # NOADJUST:      0000000000000001 func:
 # NOADJUST-NEXT:   1: {{.*}}  retq
 
 # ADJUST:        0000000000123000 sym:

llvm/test/tools/llvm-objdump/X86/out-of-section-sym.test

 // Check that llvm-objdump does not attempt to disassemble symbols outside
 // of section boundaries.
 // RUN: llvm-objdump -d -t %p/Inputs/out-of-section-sym.elf-i386 >%t0
 // RUN: llvm-objdump -dt %p/Inputs/out-of-section-sym.elf-i386 >%t1
 // RUN: cmp %t0 %t1
 // RUN: FileCheck --input-file %t0 %s
 
 CHECK: SYMBOL TABLE:
 CHECK-NEXT: 00000010 l    d  .text  00000000 .text
-CHECK-NEXT: 00000010         .text  00000000 _start
-CHECK-NEXT: 00000020         .text  00000000 _fdata
-CHECK-NEXT: 00000010         .text  00000000 _ftext
+CHECK-NEXT: 00000010 l       .text  00000000 _start
+CHECK-NEXT: 00000020 g       .text  00000000 _fdata
+CHECK-NEXT: 00000010 g       .text  00000000 _ftext
 CHECK-EMPTY:
 CHECK-NEXT: Disassembly of section .text:
 CHECK-EMPTY:
 CHECK-NEXT: _start:
 CHECK-NEXT:   10:  c3  retl

llvm/test/tools/llvm-objdump/common-symbol-elf.test

 // RUN: llvm-objdump -t %p/Inputs/common-symbol-elf | FileCheck %s
 
-CHECK: 00000400 g     O *COM*  00000008 common_symbol
+CHECK: 00000400       O *COM*  00000008 common_symbol

llvm/tools/llvm-objdump/llvm-objdump.cpp

for (auto I = O->symbol_begin(), E = O->symbol_end(); I != E; ++I) {
 
     bool Global = Flags & SymbolRef::SF_Global;
     bool Weak = Flags & SymbolRef::SF_Weak;
     bool Absolute = Flags & SymbolRef::SF_Absolute;
     bool Common = Flags & SymbolRef::SF_Common;
     bool Hidden = Flags & SymbolRef::SF_Hidden;
 
     char GlobLoc = ' ';
-    if (Type != SymbolRef::ST_Unknown)
+    if ((Section != O->section_end() || Absolute) && !Weak)
       GlobLoc = Global ? 'g' : 'l';
     char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
                  ? 'd' : ' ';
     char FileFunc = ' ';
     if (Type == SymbolRef::ST_File)
       FileFunc = 'f';
     else if (Type == SymbolRef::ST_Function)
       FileFunc = 'F';