[obj2yaml] - Dump allocatable SHT_STRTAB, SHT_SYMTAB and SHT_DYNSYM sections.

[grimar]

Summary

Sometimes we need to dump an object and build it again from a YAML
description produced. The problem is that obj2yaml does not dump some
of sections, like string tables and symbol tables.

Because of that yaml2obj implicitly creates them and sections created
are not placed at their original locations. They are added to the end of a section list.
That makes a preparing test cases task harder than it can be.

This patch teaches obj2yaml to dump parts of allocatable SHT_STRTAB, SHT_SYMTAB
and SHT_DYNSYM sections to print placeholders for them.
This also allows to preserve usefull parameters, like virtual address.

[MaskRay]

Since rL238073, clang no longer produces .shstrtab, but rather uses a unified .strtab for both section names and symbol names. Dumping SHT_STRTAB is necessary to differentiate the two cases.

Do you mean that yaml2obj generated SHT_DYNSYM is not at the normal place (early in the section header table, somewhere before .rodata)?

llvm/tools/obj2yaml/elf2yaml.cpp

258

The contents of these sections are described by other parts of the YAML file. We still dump them so that their positions in the section header table are correctly recorded.

[grimar]

In D74955#1886907, @MaskRay wrote:

Since rL238073, clang no longer produces .shstrtab, but rather uses a unified .strtab for both section names and symbol names. Dumping SHT_STRTAB is necessary to differentiate the two cases.

Do you mean that yaml2obj generated SHT_DYNSYM is not at the normal place (early in the section header table, somewhere before .rodata)?

No. The place is just different from the one in the original object.
See: imagine we have test.s:

.data
.section .bar,"a"
.quad .bar

.text
.section .foo,"ax"
.quad .foo

.section .zed,"ax"
.quad .foo

and do:

as test.s -o test.o
ld.bfd test.o -shared -o test.so

We have an output with the following section headers:

Section Headers:

[Nr] Name              Type             Address           Offset
     Size              EntSize          Flags  Link  Info  Align
[ 0]                   NULL             0000000000000000  00000000
     0000000000000000  0000000000000000           0     0     0
[ 1] .hash             HASH             0000000000000190  00000190
     0000000000000010  0000000000000004   A       3     0     8
[ 2] .gnu.hash         GNU_HASH         00000000000001a0  000001a0
     000000000000001c  0000000000000000   A       3     0     8
[ 3] .dynsym           DYNSYM           00000000000001c0  000001c0
     0000000000000018  0000000000000018   A       4     1     8
[ 4] .dynstr           STRTAB           00000000000001d8  000001d8
     0000000000000001  0000000000000000   A       0     0     1
[ 5] .rela.dyn         RELA             00000000000001e0  000001e0
     0000000000000048  0000000000000018   A       3     0     8
[ 6] .foo              PROGBITS         0000000000001000  00001000
     0000000000000008  0000000000000000  AX       0     0     1
[ 7] .zed              PROGBITS         0000000000001008  00001008
     0000000000000008  0000000000000000  AX       0     0     1
[ 8] .bar              PROGBITS         0000000000002000  00002000
     0000000000000008  0000000000000000   A       0     0     1
[ 9] .eh_frame         PROGBITS         0000000000002008  00002008
     0000000000000000  0000000000000000   A       0     0     8
[10] .dynamic          DYNAMIC          0000000000003ef0  00002ef0
     0000000000000110  0000000000000010  WA       4     0     8
[11] .symtab           SYMTAB           0000000000000000  00003000
     0000000000000120  0000000000000018          12    12     8
[12] .strtab           STRTAB           0000000000000000  00003120
     000000000000000a  0000000000000000           0     0     1
[13] .shstrtab         STRTAB           0000000000000000  0000312a
     0000000000000061  0000000000000000           0     0     1

Then after invoking obj2yaml and yaml2obj we have:

[Nr] Name              Type             Address           Offset
      Size              EntSize          Flags  Link  Info  Align
 [ 0]                   NULL             0000000000000000  00000000
      0000000000000000  0000000000000000           0     0     0
 [ 1] .hash             HASH             0000000000000190  00000040
      0000000000000010  0000000000000000   A       9     0     8
 [ 2] .gnu.hash         GNU_HASH         00000000000001a0  00000050
      000000000000001c  0000000000000000   A       9     0     8
 [ 3] .rela.dyn         RELA             00000000000001e0  00000070
      0000000000000048  0000000000000018   A       9     0     8
 [ 4] .foo              PROGBITS         0000000000001000  000000b8
      0000000000000008  0000000000000000  AX       0     0     1
 [ 5] .zed              PROGBITS         0000000000001008  000000c0
      0000000000000008  0000000000000000  AX       0     0     1
 [ 6] .bar              PROGBITS         0000000000002000  000000c8
      0000000000000008  0000000000000000   A       0     0     1
 [ 7] .eh_frame         PROGBITS         0000000000002008  000000d0
      0000000000000000  0000000000000000   A       0     0     8
 [ 8] .dynamic          DYNAMIC          0000000000003ef0  000000d0
      0000000000000110  0000000000000010  WA      10     0     8
 [ 9] .dynsym           DYNSYM           0000000000000000  000001e0
      0000000000000018  0000000000000018   A      10     1     8
 [10] .dynstr           STRTAB           0000000000000000  000001f8
      0000000000000001  0000000000000000   A       0     0     1
 [11] .symtab           SYMTAB           0000000000000000  00000200
      0000000000000120  0000000000000018          12    12     8
 [12] .strtab           STRTAB           0000000000000000  00000320
      0000000000000050  0000000000000000           0     0     1
 [13] .shstrtab         STRTAB           0000000000000000  00000370
      0000000000000061  0000000000000000           0     0     1

Note that .dynsym and .dynstr changed their location. That happened
because obj2yaml did not dump them and hence yaml2obj added them to the end of the list,
together with .symtab,.strtab and .shstrtab.
With this patch it is possible to preserve the original sections order as obj2yaml starts to create placeholders for them.

[MaskRay]

Sometimes we need to dump an object and build it again from a YAML description produced. The problem is that obj2yaml does not dump some of sections, like string tables and symbol tables.

Because of that yaml2obj implicitly creates them and sections created are not placed at their original locations. They are added to the end of a section list. That makes a preparing test cases task harder than it can be.

The description is verbose. Just mention that obj2yaml does not dump SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM. This is problematic because the output YAML loses track of their positions in the section header table and makes objyaml->yaml2obj round trip fail.

[jhenderson]

I've not yet looked at the actual details of this change, but I wanted to flag up a concern: if we always dump these sections, we will see extra parts in the YAML of obj2yaml output that are actually unnecessary in many (most?) instances. As a result, people will start writing tests with extra useless details in, as many people use obj2yaml to generate the YAML for a test input, since they don't know enough about how to write YAML from scratch. We would then review these tests and ask people to remove the noise from the YAML (i.e. the unnecessary .dynsym etc descriptions), so that it is clearer what is being tested. We already do this for other things that aren't needed (e.g. section alignments), which I know can be irritating for some people. Now we're making them do yet more work for only a little gain.

I don't have a clear solution to this yet, as I agree we shouldn't throw away important information like section addresses when using obj2yaml. I'm not concerned by the section header order, as that technically has no impact on anything (as long as section indexes in other things are updated correctly). Could we perhaps only list the implicit sections when they have a non-default value for something (i.e. a value that would be different from when they are not specified, such as a non-zero address)?

[grimar]

In D74955#1890908, @jhenderson wrote:

I don't have a clear solution to this yet, as I agree we shouldn't throw away important information like section addresses when using obj2yaml. I'm not concerned by the section header order, as that technically has no impact on anything (as long as section indexes in other things are updated correctly).

In my use case the order is important. In short: I've experimented with a code to dump program headers and make an object produced
after obj->obj2yaml->yaml2obj->obj operation have the same segments, sections in segments etc.
In this case it is important to keep the order and addresses of allocatable implicit sections.

Could we perhaps only list the implicit sections when they have a non-default value for something (i.e. a value that would be different from when they are not specified, such as a non-zero address)?

A non-zero address for allocatable sections is pretty common. I.e. we will always print .dynsym/.dynstr sections..

My concern is also that reading SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM and printing
different from "default" ones is a much more complicated logic than simply dumping them as RawContentSection, like this patch does.

What if we introduce an option, e.g. --dump-implicit-sec to dump them? It could be used for test cases creating
purposes and hide such details what should work good for a general case probably.

[jhenderson]

In D74955#1891281, @grimar wrote:

In D74955#1890908, @jhenderson wrote:

I don't have a clear solution to this yet, as I agree we shouldn't throw away important information like section addresses when using obj2yaml. I'm not concerned by the section header order, as that technically has no impact on anything (as long as section indexes in other things are updated correctly).

In my use case the order is important. In short: I've experimented with a code to dump program headers and make an object produced
after obj->obj2yaml->yaml2obj->obj operation have the same segments, sections in segments etc.
In this case it is important to keep the order and addresses of allocatable implicit sections.

Could we perhaps only list the implicit sections when they have a non-default value for something (i.e. a value that would be different from when they are not specified, such as a non-zero address)?

A non-zero address for allocatable sections is pretty common. I.e. we will always print .dynsym/.dynstr sections..

My concern is also that reading SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM and printing
different from "default" ones is a much more complicated logic than simply dumping them as RawContentSection, like this patch does.

What if we introduce an option, e.g. --dump-implicit-sec to dump them? It could be used for test cases creating
purposes and hide such details what should work good for a general case probably.

Okay, you make a fair amount of sense. I don't think a switch is necessarily needed. That being said, perhaps we could limit this to the dynamic symbol table and dynamic string table? I feel like .symtab and the non-dynamic string table(s) do not need printing, since they will normally be at the end, don't have addresses, and will just cause unnecessary noise if in the YAML. I think you'll find the number of tests impacted will subsequently reduce significantly. Perhaps then a switch (e.g. --explicit-symtab-strtab) would be wise to enable dumping these sections. What do you think?

[grimar]

In D74955#1894987, @jhenderson wrote:

Okay, you make a fair amount of sense. I don't think a switch is necessarily needed. That being said, perhaps we could limit this to the dynamic symbol table and dynamic string table? I feel like .symtab and the non-dynamic string table(s) do not need printing, since they will normally be at the end, don't have addresses, and will just cause unnecessary noise if in the YAML.

I think it is fine, I've also though about such possibility and during work on another patch also realized that dumping just allocatable sections is enough at least for my current use cases.

I think you'll find the number of tests impacted will subsequently reduce significantly. Perhaps then a switch (e.g. --explicit-symtab-strtab) would be wise to enable dumping these sections. What do you think?

Sounds good to me too.

[grimar]

Will change in according to discussion.

[grimar]

• Dump only allocatable sections.

[MaskRay]

Dump allocatable SHT_STRTAB, SHT_SYMTAB and SHT_DYNSYM sections.

.dynstr => allocatable SHT_STRTAB
.dynsym => SHT_DYNSYM

I haven't seen a case for allocatable SHT_SYMTAB but due to how the switch cases are organized, I think it does not hurt to place SHT_SYMTAB there.

Non-allocatable SHT_STRTAB and SHT_SYMTAB and usually in the end of the file. Their presence changes offsets of themselves and the section header table. Making them implicit seems fine.

With this scheme, a new option will not be needed. I am in favor of such a change.

[grimar]

• Updated comments in the implicit-sections-order.yaml test case.

[jhenderson]

A thought, but I think it's a pre-existing issue: let's say I have a custom SHT_STRTAB section that isn't the symbol or section header string table. This code seems to prevent that section being emitted?

llvm/test/tools/obj2yaml/duplicate-symbol-and-section-names.test

128

Unrelated change which should probably be committed separately?

llvm/test/tools/obj2yaml/implicit-sections-order.yaml

8

Here and below, maybe instead of "print" you should say "explicitly declare" or something to that effect?

115

ubnormal -> abnormal

llvm/tools/obj2yaml/elf2yaml.cpp

260

Perhaps worth saying why we only dump allocatable sections a little more directly.

261

Another ones -> Some sections

262

address -> addresses

[grimar]

In D74955#1897495, @jhenderson wrote:

A thought, but I think it's a pre-existing issue: let's say I have a custom SHT_STRTAB section that isn't the symbol or section header string table. This code seems to prevent that section being emitted?

Before this patch seems we never emitted those. With this patch we will emit something (but not the Content for example) for allocatable sections and will emit nothing for non-allocatable.
So, situation is slightly better with this patch, but still far from ideal.

llvm/test/tools/obj2yaml/duplicate-symbol-and-section-names.test

128

It is related: now between the FileHeader key and Symbols there are also Sections because .dynsym/.dynstr are created.

[grimar]

• Addressed review comments.

[jhenderson]

LGTM.

llvm/test/tools/obj2yaml/duplicate-symbol-and-section-names.test

Symbols:
   - Name: 'foo [1]'
 
 ## Check obj2yaml does not add a suffix to a name if the
 ## symbol is in .symtab and .dynsym at the same time.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=CASE3
 
-# CASE3:      --- !ELF
-# CASE3-NEXT: FileHeader:
-# CASE3-NEXT:   Class:   ELFCLASS64
-# CASE3-NEXT:   Data:    ELFDATA2LSB
-# CASE3-NEXT:   Type:    ET_DYN
-# CASE3-NEXT:   Machine: EM_X86_64
-# CASE3-NEXT: Symbols:
+# CASE3:      Symbols:
 # CASE3-NEXT:   - Name:    foo
 # CASE3-NEXT:     Binding: STB_GLOBAL
 # CASE3-NEXT: DynamicSymbols:
 # CASE3-NEXT:   - Name:    foo
 # CASE3-NEXT:     Binding: STB_GLOBAL
 
 --- !ELF
 FileHeader:

llvm/test/tools/obj2yaml/implicit-sections-order.yaml

+## Check that obj2yaml dumps SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM sections
+## when they are allocatable.
+
+## In the following test we check the normal case: when .dynsym (SHT_DYNSYM)
+## and .dynstr (SHT_STRTAB) are allocatable sections and .symtab (SHT_SYMTAB),
+## .strtab (SHT_STRTAB) and .shstrtab (SHT_STRTAB) are not.
+## Check we explicitly declare allocatable sections.
+
+# RUN: yaml2obj %s -o %t1.so -D FLAG1=SHF_ALLOC -D FLAG2=""
+# RUN: llvm-readelf -S %t1.so | FileCheck %s --check-prefixes=RE,RE-1
+# RUN: obj2yaml %t1.so | FileCheck %s --check-prefix=OUTPUT
+
+## Check the information about sections using an independent tool.
+
+# RE:        Section Headers:
+# RE-NEXT:   [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
+# RE-NEXT:   [ 0]           NULL     0000000000000000 000000 000000 00     0   0  0
+# RE-NEXT:   [ 1] .foo.1    PROGBITS 0000000000000000 000040 000000 00     0   0  0
+# RE-1-NEXT: [ 2] .dynsym   DYNSYM   0000000000001000 000040 000030 18   A 4   2  0
+# RE-2-NEXT: [ 2] .dynsym   DYNSYM   0000000000001000 000040 000030 18     4   2  0
+# RE-NEXT:   [ 3] .foo.2    PROGBITS 0000000000000000 000070 000000 00     0   0  0
+# RE-1-NEXT: [ 4] .dynstr   STRTAB   0000000000002000 000070 000005 00   A 0   0  0
+# RE-2-NEXT: [ 4] .dynstr   STRTAB   0000000000002000 000070 000005 00     0   0  0
+# RE-NEXT:   [ 5] .foo.3    PROGBITS 0000000000000000 000075 000000 00     0   0  0
+# RE-1-NEXT: [ 6] .symtab   SYMTAB   0000000000003000 000075 000030 18     8   2  0
+# RE-2-NEXT: [ 6] .symtab   SYMTAB   0000000000003000 000075 000030 18   A 8   2  0
+# RE-NEXT:   [ 7] .foo.4    PROGBITS 0000000000000000 0000a5 000000 00     0   0  0
+# RE-1-NEXT: [ 8] .strtab   STRTAB   0000000000004000 0000a5 000005 00     0   0  0
+# RE-2-NEXT: [ 8] .strtab   STRTAB   0000000000004000 0000a5 000005 00   A 0   0  0
+# RE-NEXT:   [ 9] .foo.5    PROGBITS 0000000000000000 0000aa 000000 00     0   0  0
+# RE-1-NEXT: [10] .shstrtab STRTAB   0000000000005000 0000aa 000055 00     0   0  0
+# RE-2-NEXT: [10] .shstrtab STRTAB   0000000000005000 0000aa 000055 00   A 0   0  0
+# RE-NEXT:   [11] .foo.6    PROGBITS 0000000000000000 0000ff 000000 00     0   0  0
+
+# OUTPUT:      --- !ELF
+# OUTPUT-NEXT: FileHeader:
+# OUTPUT-NEXT:   Class:   ELFCLASS64
+# OUTPUT-NEXT:   Data:    ELFDATA2LSB
+# OUTPUT-NEXT:   Type:    ET_DYN
+# OUTPUT-NEXT:   Machine: EM_X86_64
+# OUTPUT-NEXT: Sections:
+# OUTPUT-NEXT:   - Name: .foo.1
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name:    .dynsym
+# OUTPUT-NEXT:     Type:    SHT_DYNSYM
+# OUTPUT-NEXT:     Flags:   [ SHF_ALLOC ]
+# OUTPUT-NEXT:     Address: 0x0000000000001000
+# OUTPUT-NEXT:     Link:    .dynstr
+# OUTPUT-NEXT:     EntSize: 0x0000000000000018
+# OUTPUT-NEXT:   - Name: .foo.2
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name:    .dynstr
+# OUTPUT-NEXT:     Type:    SHT_STRTAB
+# OUTPUT-NEXT:     Flags:   [ SHF_ALLOC ]
+# OUTPUT-NEXT:     Address: 0x0000000000002000
+# OUTPUT-NEXT:   - Name: .foo.3
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name: .foo.4
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name: .foo.5
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name: .foo.6
+# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT: Symbols:
+# OUTPUT-NEXT:   - Name: foo
+# OUTPUT-NEXT: DynamicSymbols:
+# OUTPUT-NEXT:   - Name: bar
+# OUTPUT-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo.1
+    Type: SHT_PROGBITS
+  - Name:    .dynsym
+    Type:    SHT_DYNSYM
+    Address: 0x1000
+    Flags: [ [[FLAG1]] ]
+  - Name: .foo.2
+    Type: SHT_PROGBITS
+  - Name:    .dynstr
+    Type:    SHT_STRTAB
+    Address: 0x2000
+    Flags: [ [[FLAG1]] ]
+  - Name: .foo.3
+    Type: SHT_PROGBITS
+  - Name:    .symtab
+    Type:    SHT_SYMTAB
+    Address: 0x3000
+    Flags: [ [[FLAG2]] ]
+  - Name: .foo.4
+    Type: SHT_PROGBITS
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+    Address: 0x4000
+    Flags: [ [[FLAG2]] ]
+  - Name: .foo.5
+    Type: SHT_PROGBITS
+  - Name:    .shstrtab
+    Type:    SHT_STRTAB
+    Address: 0x5000
+    Flags: [ [[FLAG2]] ]
+  - Name: .foo.6
+    Type: SHT_PROGBITS
+Symbols:
+  - Name: foo
+DynamicSymbols:
+  - Name: bar
+
+## Now test the abnormal case: when .symtab (SHT_SYMTAB),
+## .strtab (SHT_STRTAB) and .shstrtab (SHT_STRTAB) are
+## allocatable sections, but .dynsym (SHT_DYNSYM) and
+## .dynstr (SHT_STRTAB) are not.
+## Check that only allocatable versions are explicitly declared.
+
+# RUN: yaml2obj %s -o %t2.so -D FLAG1="" -D FLAG2=SHF_ALLOC
+# RUN: llvm-readelf -S %t2.so | FileCheck %s --check-prefixes=RE,RE-2
+# RUN: obj2yaml %t2.so | FileCheck %s --check-prefix=OUTPUT2
+
+## Check we explicitly declare only allocatable
+## SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM sections.
+# OUTPUT2:      --- !ELF
+# OUTPUT2-NEXT: FileHeader:
+# OUTPUT2-NEXT:   Class:   ELFCLASS64
+# OUTPUT2-NEXT:   Data:    ELFDATA2LSB
+# OUTPUT2-NEXT:   Type:    ET_DYN
+# OUTPUT2-NEXT:   Machine: EM_X86_64
+# OUTPUT2-NEXT: Sections:
+# OUTPUT2-NEXT:   - Name: .foo.1
+# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name: .foo.2
+# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name: .foo.3
+# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name:    .symtab
+# OUTPUT2-NEXT:     Type:    SHT_SYMTAB
+# OUTPUT2-NEXT:     Flags:   [ SHF_ALLOC ]
+# OUTPUT2-NEXT:     Address: 0x0000000000003000
+# OUTPUT2-NEXT:     Link:    .strtab
+# OUTPUT2-NEXT:     EntSize: 0x0000000000000018
+# OUTPUT2-NEXT:   - Name: .foo.4
+# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name:    .strtab
+# OUTPUT2-NEXT:     Type:    SHT_STRTAB
+# OUTPUT2-NEXT:     Flags:   [ SHF_ALLOC ]
+# OUTPUT2-NEXT:     Address: 0x0000000000004000
+# OUTPUT2-NEXT:   - Name: .foo.5
+# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name:    .shstrtab
+# OUTPUT2-NEXT:     Type:    SHT_STRTAB
+# OUTPUT2-NEXT:     Flags:   [ SHF_ALLOC ]
+# OUTPUT2-NEXT:     Address: 0x0000000000005000
+# OUTPUT2-NEXT:   - Name:    .foo.6
+# OUTPUT2-NEXT:     Type:    SHT_PROGBITS
+# OUTPUT2-NEXT: Symbols:
+# OUTPUT2-NEXT:   - Name: foo
+# OUTPUT2-NEXT: DynamicSymbols:
+# OUTPUT2-NEXT:   - Name: bar
+# OUTPUT2-NEXT: ...

llvm/test/tools/obj2yaml/versym-section.yaml

 # CHECK-NEXT:   - Name:            .gnu.version
 # CHECK-NEXT:     Type:            SHT_GNU_versym
 # CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
 # CHECK-NEXT:     Address:         0x0000000000200210
 # CHECK-NEXT:     Link:            .dynsym
 # CHECK-NEXT:     AddressAlign:    0x0000000000000002
 # CHECK-NEXT:     EntSize:         0x0000000000000002
 # CHECK-NEXT:     Entries:         [ 0, 3, 4 ]
-# CHECK-NEXT: DynamicSymbols:
+# CHECK-NEXT:   - Name:
+# CHECK:      DynamicSymbols:
 # CHECK-NEXT:   - Name:    f1
 # CHECK-NEXT:     Binding: STB_GLOBAL
 # CHECK-NEXT:   - Name:    f2
 # CHECK-NEXT:     Binding: STB_GLOBAL
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64

llvm/tools/obj2yaml/elf2yaml.cpp

case ELF::SHT_DYNAMIC: {
       Expected<ELFYAML::DynamicSection *> SecOrErr = dumpDynamicSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Ret.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_STRTAB:
     case ELF::SHT_SYMTAB:
-    case ELF::SHT_DYNSYM:
-      // Do not dump these sections.
+    case ELF::SHT_DYNSYM: {
+      // The contents of these sections are described by other parts of the YAML
+      // file. We still dump them so that their positions in the section header
+      // table are correctly recorded. We only dump allocatable section because
+      // their positions and addresses are important, e.g. for creating program
+      // headers. Some sections, like .symtab or .strtab normally are not
+      // allocatable and do not have virtual addresses. We want to avoid noise
+      // in the YAML output and assume that they are placed at the end.
+      if (Sec.sh_flags & ELF::SHF_ALLOC) {
+        auto S = std::make_unique<ELFYAML::RawContentSection>();
+        if (Error E = dumpCommonSection(&Sec, *S.get()))
+          return std::move(E);
+        Ret.emplace_back(std::move(S));
+      }
       break;
+    }
     case ELF::SHT_SYMTAB_SHNDX: {
       Expected<ELFYAML::SymtabShndxSection *> SecOrErr =
           dumpSymtabShndxSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Ret.emplace_back(*SecOrErr);
       break;
     }