[llvm-objcopy][ELF] Avoid reordering section headers

[ikudrin]

Summary

As for now, llvm-objcopy sorts section headers according to the offsets of the sections in the input file. That can corrupt section references in the dynamic symbol table because it is a loadable section and as such is not updated by the tool. Even though the section references are not required for loading the binary correctly, they are still handy for a user who analyzes the file.

While the patch removes global reordering of section headers, it layouts the sections in the same way as before, i.e. according to their original offsets. All that helps the output file to resemble the input better.

Note that the patch removes sorting SHT_GROUP sections to the start of the list, which was introduced in D62620 in order to ensure that they come before the group members, along with the corresponding test. The original issue was caused by the sorting of section headers, so dropping the sorting also resolves the issue.

[ikudrin]

• When debug sections are compressed or decompressed, place the new sections at the positions of removed ones. That fixes failures in compress-debug-sections-zlib.test and compress-debug-sections-zlib-gnu.test.

[ikudrin]

• Fixed a code formatting issue

[MaskRay]

D62620 was related to section groups: "The section header table entry for a group section must appear in the section header table before the entries for any of the sections that are members of the group."
(ld.lld has dropped the limitation)

That can corrupt section references in the dynamic symbol table because it is a loadable section and as such is not updated by the tool. Even though the section references are not required for loading the binary correctly, they are still handy for a user who analyzes the file.

All dynamic loaders I know only use 3 categories:

• SHN_UNDEF
• SHN_ABS
• other values

There are no behavior differences if an index of 1 is replaced with 2, but I agree that preserving the section index and making the output as close to the input as possible will be nice.

The approach looks good at a glance, but I'll need to look more closely tomorrow.

llvm/test/tools/llvm-objcopy/ELF/dynsym-valid-refs.test

56

Add a comment that dummy is before .text by intention even if its offset is larger.

[ikudrin]

• Added a comment that 'dummy' comes before '.text' by intention.

In D107653#2936087, @MaskRay wrote:

D62620 was related to section groups: "The section header table entry for a group section must appear in the section header table before the entries for any of the sections that are members of the group."
(ld.lld has dropped the limitation)

Right, D62620 enforces SHT_GROUP sections to be moved at the start of the table. That was required because the tool sorted section headers and, without the fix, could place such sections in the table after members of their groups. This patch drops sorting, so there is no need to do anything special for group sections.

That can corrupt section references in the dynamic symbol table because it is a loadable section and as such is not updated by the tool. Even though the section references are not required for loading the binary correctly, they are still handy for a user who analyzes the file.

All dynamic loaders I know only use 3 categories:

• SHN_UNDEF
• SHN_ABS
• other values

There are no behavior differences if an index of 1 is replaced with 2, but I agree that preserving the section index and making the output as close to the input as possible will be nice.

My point exactly. Skewed section references can bewilder a person, but not a dynamic loader.

The approach looks good at a glance, but I'll need to look more closely tomorrow.

Thanks!

[MaskRay]

Looks good.

llvm/tools/llvm-objcopy/ELF/Object.cpp

2317

No test fails if I comment out this stable_sort .

You may need a --only-keep-debug test.

[ikudrin]

• Added a test for --only-keep-debug
• Moved updating references for replaced sections from replaceDebugSections() to Object::replaceSections()

[MaskRay]

LGTM.

llvm/test/tools/llvm-objcopy/ELF/dwarf-fission.test

 # RUN: llvm-objcopy --extract-dwo %p/Inputs/dwarf.dwo %t
 # RUN: llvm-objcopy --strip-dwo %p/Inputs/dwarf.dwo %t2
 # RUN: llvm-objcopy --split-dwo=%t3 %p/Inputs/dwarf.dwo %t4
 # RUN: llvm-readobj --file-headers --sections %t | FileCheck %s --check-prefix=DWARF
 # RUN: llvm-readobj --file-headers --sections %t2 | FileCheck %s --check-prefix=STRIP
 # RUN: diff %t %t3
 # RUN: diff %t2 %t4
 
 #DWARF:     SectionHeaderCount: 8
 
+#DWARF:     Name: .strtab
 #DWARF:     Name: .debug_loc.dwo
 #DWARF:     Name: .debug_str.dwo
 #DWARF:     Name: .debug_str_offsets.dwo
 #DWARF:     Name: .debug_info.dwo
 #DWARF:     Name: .debug_abbrev.dwo
 #DWARF:     Name: .debug_line.dwo
-#DWARF:     Name: .strtab
 
 #STRIP:     SectionHeaderCount: 24
 
+#STRIP:    Name: .strtab
 #STRIP:    Name: .text
+#STRIP:    Name: .rela.text
 #STRIP:    Name: .rodata.str1.1
 #STRIP:    Name: .debug_str
 #STRIP:    Name: .debug_abbrev
 #STRIP:    Name: .debug_info
+#STRIP:    Name: .rela.debug_info
 #STRIP:    Name: .debug_ranges
 #STRIP:    Name: .debug_macinfo
 #STRIP:    Name: .debug_addr
+#STRIP:    Name: .rela.debug_addr
 #STRIP:    Name: .debug_pubnames
+#STRIP:    Name: .rela.debug_pubnames
 #STRIP:    Name: .debug_pubtypes
+#STRIP:    Name: .rela.debug_pubtypes
 #STRIP:    Name: .comment
 #STRIP:    Name: .note.GNU-stack
 #STRIP:    Name: .debug_frame
-#STRIP:    Name: .debug_line
-#STRIP:    Name: .symtab
-#STRIP:    Name: .rela.text
-#STRIP:    Name: .rela.debug_info
-#STRIP:    Name: .rela.debug_addr
-#STRIP:    Name: .rela.debug_pubnames
-#STRIP:    Name: .rela.debug_pubtypes
 #STRIP:    Name: .rela.debug_frame
+#STRIP:    Name: .debug_line
 #STRIP:    Name: .rela.debug_line
-#STRIP:    Name: .strtab
+#STRIP:    Name: .symtab

llvm/test/tools/llvm-objcopy/ELF/dynsym-valid-refs.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy %t %t2
+# RUN: llvm-readobj --dyn-syms %t2 | FileCheck %s
+
+## This checks that section references in the dynamic symbol table are not
+## corrupted after processing a file where the sequence of section headers does
+## not follow the order of their offsets. The tool avoids updating loadable
+## sections, so, the content of the dynamic symbol table stays intact and the
+## used section indices are preserved. In this test, the section 'dummy' comes
+## first while having the offset after all other sections. If the section
+## headers were sorted by their offsets by the tool, what it did before, the
+## index of the '.text' section would change from '2' to '1', which resulted
+## in an incorrect reference in the corresponding dynamic symbol 'foo'.
+
+# CHECK:      Name: foo
+# CHECK-NEXT: Value:
+# CHECK-NEXT: Size:
+# CHECK-NEXT: Binding:
+# CHECK-NEXT: Type:
+# CHECK-NEXT: Other:
+# CHECK-NEXT: Section: .text
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+ProgramHeaders:
+  - Type:            PT_LOAD
+    Flags:           [ PF_X, PF_R ]
+    FirstSec:        .text
+    LastSec:         .text
+    Align:           0x1000
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x4
+    Offset:          0x1000
+    Content:         0000000000000000
+  - Name:            .dynsym
+    Type:            SHT_DYNSYM
+    Flags:           [ SHF_ALLOC ]
+    Link:            .dynstr
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+  - Name:            dummy
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Offset:          0x1100
+  - Type:            SectionHeaderTable
+    Sections:
+## 'dummy' comes before '.text' in the section header table despite its offset
+## is larger.
+      - Name:            dummy
+      - Name:            .text
+      - Name:            .dynsym
+      - Name:            .dynstr
+      - Name:            .shstrtab
+      - Name:            .strtab
+DynamicSymbols:
+  - Name:            foo
+    Type:            STT_FUNC
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Value:           0x0
+    Size:            0x8

llvm/test/tools/llvm-objcopy/ELF/group-reorder.test

-# RUN: yaml2obj %s -o %t.o
-# RUN: llvm-objcopy %t.o %t.2.o
-# RUN: llvm-readelf --section-groups --sections %t.o | FileCheck %s --check-prefix=IN
-# RUN: llvm-readelf --section-groups --sections %t.2.o | FileCheck %s --check-prefix=OUT
-
-# In this test, .group gets moved to the beginning. Run readelf -gS on input as
-# well as output to make sure it really moved, as well as to verify that we
-# aren't purely sorting based on offsets (it gets moved to the beginning
-# despite having a larger offset).
-
-# IN:      There are 7 section headers, starting at offset 0x160:
-# IN:        [Nr] Name              Type            Address          Off    Size
-# IN-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000
-# IN-NEXT:   [ 1] .foo              PROGBITS        0000000000000000 000040 000040
-# IN-NEXT:   [ 2] .group            GROUP           0000000000000000 000080 000008
-# IN-NEXT:   [ 3] .bar              PROGBITS        0000000000000000 000088 000040
-
-# IN:      COMDAT group section [    2] `.group' [bar] contains 1 sections:
-# IN-NEXT:    [Index]    Name
-# IN-NEXT:    [    3]   .bar
-
-# OUT:      There are 7 section headers, starting at offset 0x160:
-# OUT:        [Nr] Name              Type            Address          Off    Size
-# OUT-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000
-# OUT-NEXT:   [ 1] .group            GROUP           0000000000000000 000040 000008
-# OUT-NEXT:   [ 2] .foo              PROGBITS        0000000000000000 000048 000040
-# OUT-NEXT:   [ 3] .bar              PROGBITS        0000000000000000 000088 000040
-
-# OUT:      COMDAT group section [    1] `.group' [bar] contains 1 sections:
-# OUT-NEXT:    [Index]    Name
-# OUT-NEXT:    [    3]   .bar
-
---- !ELF
-FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_REL
-  Machine:         EM_X86_64
-Sections:
-  - Name:            .foo
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Size:            64
-  - Name:            .group
-    Type:            SHT_GROUP
-    Link:            .symtab
-    Info:            bar
-    Members:
-      - SectionOrType:   GRP_COMDAT
-      - SectionOrType:   .bar
-  - Name:            .bar
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
-    Size:            64
-Symbols:
-  - Name:            .foo
-    Type:            STT_SECTION
-    Section:         .foo
-  - Name:            .bar
-    Type:            STT_SECTION
-    Section:         .bar
-  - Name:            bar
-    Type:            STT_FUNC
-    Binding:         STB_GLOBAL
-    Section:         .foo

llvm/test/tools/llvm-objcopy/ELF/ihex-reader.test

 ## Check section headers when converting from hex to ELF.
 # RUN: yaml2obj %p/Inputs/ihex-elf-sections.yaml -o %t
 # RUN: llvm-objcopy -O ihex %t %t.hex
 # RUN: llvm-objcopy -I ihex -O elf32-i386 %t.hex %t2
 # RUN: llvm-readobj --section-headers %t2 | FileCheck %s
 
-# CHECK:         Index: 1
-# CHECK-NEXT:    Name: .sec1
+# CHECK:         Name: .sec1
 # CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:    Flags [ (0x3)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:      SHF_WRITE (0x1)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x0
-# CHECK-NEXT:    Offset: 0x34
+# CHECK-NEXT:    Offset:
 # CHECK-NEXT:    Size: 21
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
 
-# CHECK:         Index: 2
-# CHECK-NEXT:    Name: .sec2
+# CHECK:         Name: .sec2
 # CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:    Flags [ (0x3)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:      SHF_WRITE (0x1)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0xFFF8
-# CHECK-NEXT:    Offset: 0x49
+# CHECK-NEXT:    Offset:
 # CHECK-NEXT:    Size: 11
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
 
-# CHECK:         Index: 3
-# CHECK-NEXT:    Name: .sec3
+# CHECK:         Name: .sec3
 # CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:    Flags [ (0x3)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:      SHF_WRITE (0x1)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x10100
-# CHECK-NEXT:    Offset: 0x54
+# CHECK-NEXT:    Offset:
 # CHECK-NEXT:    Size: 4
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
 
-# CHECK:         Index: 4
-# CHECK-NEXT:    Name: .sec4
+# CHECK:         Name: .sec4
 # CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:    Flags [ (0x3)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:      SHF_WRITE (0x1)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x10FFF8
-# CHECK-NEXT:    Offset: 0x58
+# CHECK-NEXT:    Offset:
 # CHECK-NEXT:    Size: 11
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
-  
 ## Check section contents.
 # RUN: llvm-objcopy -O binary --only-section=.text %t %t.text
 # RUN: llvm-objcopy -O binary --only-section=.sec1 %t2 %t2.sec1
 # RUN: cmp %t.text %t2.sec1
 # RUN: llvm-objcopy -O binary --only-section=.data %t %t.data
 # RUN: llvm-objcopy -O binary --only-section=.sec2 %t2 %t2.sec2
 # RUN: cmp %t.data %t2.sec2
 # RUN: llvm-objcopy -O binary --only-section=.data2 %t %t.data2
 # RUN: llvm-objcopy -O binary --only-section=.sec3 %t2 %t2.sec3
 # RUN: cmp %t.data2 %t2.sec3
 # RUN: llvm-objcopy -O binary --only-section=.data3 %t %t.data3
 # RUN: llvm-objcopy -O binary --only-section=.sec4 %t2 %t2.sec4
 # RUN: cmp %t.data3 %t2.sec4
 
 ## Check loading from raw hex file.
 # RUN: llvm-objcopy -I ihex -O elf32-i386 %p/Inputs/sections.hex %t-raw
 # RUN: llvm-readobj --section-headers %t-raw | FileCheck %s --check-prefix=RAW
 
-# RAW:          Index: 1
-# RAW-NEXT:     Name: .sec1
+# RAW:          Name: .sec1
 # RAW-NEXT:     Type: SHT_PROGBITS (0x1)
 # RAW-NEXT:     Flags [ (0x3)
 # RAW-NEXT:       SHF_ALLOC (0x2)
 # RAW-NEXT:       SHF_WRITE (0x1)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Address: 0x1FFF8
-# RAW-NEXT:     Offset: 0x34
+# RAW-NEXT:     Offset:
 # RAW-NEXT:     Size: 11
 
-# RAW:          Index: 2
-# RAW-NEXT:     Name: .sec2
+# RAW:          Name: .sec2
 # RAW-NEXT:     Type: SHT_PROGBITS (0x1)
 # RAW-NEXT:     Flags [ (0x3)
 # RAW-NEXT:       SHF_ALLOC (0x2)
 # RAW-NEXT:       SHF_WRITE (0x1)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Address: 0xFFFF8
-# RAW-NEXT:     Offset: 0x3F
+# RAW-NEXT:     Offset:
 # RAW-NEXT:     Size: 11
 
-# RAW:          Index: 3
-# RAW-NEXT:     Name: .sec3
+# RAW:          Name: .sec3
 # RAW-NEXT:     Type: SHT_PROGBITS (0x1)
 # RAW-NEXT:     Flags [ (0x3)
 # RAW-NEXT:       SHF_ALLOC (0x2)
 # RAW-NEXT:       SHF_WRITE (0x1)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Address: 0x1FFFF8
-# RAW-NEXT:     Offset: 0x4A
+# RAW-NEXT:     Offset:
 # RAW-NEXT:     Size: 11
 
 ## Check section contents.
 # RUN: llvm-objcopy -O ihex --only-section=.sec1 %t-raw - | FileCheck %s --check-prefix=RAW-SEC1
 
 # RAW-SEC1:         :020000021000EC
 # RAW-SEC1-NEXT:    :08FFF8000001020304050607E5
 # RAW-SEC1-NEXT:    :020000022000DC

llvm/test/tools/llvm-objcopy/ELF/layout-sections-by-original-offsets.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy %t %t2
+# RUN: llvm-readobj --sections %t2 | FileCheck %s
+
+## This checks that llvm-objcopy layouts sections in the order of their offsets
+## in the input file in spite of the order of section headers is different.
+
+# CHECK:      Index: 1
+# CHECK-NEXT: Name: foo
+# CHECK-NEXT: Type:
+# CHECK-NEXT: Flags [
+# CHECK-NEXT:   SHF_ALLOC
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address:
+# CHECK-NEXT: Offset: 0x50
+# CHECK:      Index: 2
+# CHECK-NEXT: Name: bar
+# CHECK-NEXT: Type: SHT_PROGBITS
+# CHECK-NEXT: Flags [
+# CHECK-NEXT:   SHF_ALLOC
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address:
+# CHECK-NEXT: Offset: 0x40
+# CHECK:      Index: 3
+# CHECK-NEXT: Name: baz
+# CHECK-NEXT: Type: SHT_PROGBITS
+# CHECK-NEXT: Flags [
+# CHECK-NEXT:   SHF_ALLOC
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address:
+# CHECK-NEXT: Offset: 0x48
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            bar
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x4
+    Offset:          0x40
+    Content:         0000000000000000
+  - Name:            baz
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x4
+    Offset:          0x48
+    Content:         0000000000000000
+  - Name:            foo
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x4
+    Offset:          0x50
+    Content:         0000000000000000
+  - Type:            SectionHeaderTable
+    Sections:
+## Note: the order of section headers differs from their layout.
+      - Name:            foo
+      - Name:            bar
+      - Name:            baz
+      - Name:            .shstrtab
+      - Name:            .strtab

llvm/test/tools/llvm-objcopy/ELF/only-keep-debug.test

- Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x01000
 ProgramHeaders:
   - Type:     PT_NULL
     Flags:    []
     FileSize: 0x01000
     MemSize:  0x01000
+
+## Check that sections are placed correctly in a case when their order in the
+## section header table is different from their layout.
+# RUN: yaml2obj --docnum=6 %s -o %t6
+# RUN: llvm-objcopy --only-keep-debug %t6 %t6.dbg
+# RUN: llvm-readelf -S -l %t6.dbg | FileCheck --check-prefix=CHECK6 %s
+
+# CHECK6:      [Nr] Name        Type     Address          Off    Size   ES Flg Lk Inf Al
+# CHECK6:      [ 1] foo         NOBITS   0000000000000008 001000 000008 00   A  0   0  4
+# CHECK6-NEXT: [ 2] bar         NOBITS   0000000000000000 001000 000008 00   A  0   0  4
+# CHECK6-NEXT: [ 3] baz         NOTE     0000000000000018 001008 000008 00   A  0   0  0
+# CHECK6-NEXT: [ 4] qux         NOTE     0000000000000010 001000 000008 00   A  0   0  0
+
+# CHECK6:      Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# CHECK6-NEXT: LOAD 0x001000 0x0000000000000000 0x0000000000000000 0x000000 0x000010 R   0x1000
+# CHECK6-NEXT: LOAD 0x001000 0x0000000000000010 0x0000000000000010 0x000010 0x000010 R   0x1
+# CHECK6-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+ProgramHeaders:
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    Offset:   0x1000
+    VAddr:    0x0
+    Align:    0x1000
+    FileSize: 0x10
+    MemSize:  0x10
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    Offset:   0x1010
+    VAddr:    0x10
+    FileSize: 0x10
+    MemSize:  0x10
+Sections:
+  - Name:            bar
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0
+    AddressAlign:    0x4
+    Offset:          0x1000
+    Content:         0000000000000000
+  - Name:            foo
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x8
+    AddressAlign:    0x4
+    Offset:          0x1008
+    Content:         0000000000000000
+  - Name:            qux
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x10
+    Offset:          0x1010
+    Content:         0000000000000000
+  - Name:            baz
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x18
+    Offset:          0x1018
+    Content:         0000000000000000
+  - Type:            SectionHeaderTable
+    Sections:
+## Note: the order of section headers differs from their layout.
+      - Name:            foo
+      - Name:            bar
+      - Name:            baz
+      - Name:            qux
+      - Name:            .shstrtab
+      - Name:            .strtab

llvm/test/tools/llvm-objcopy/ELF/shared-strtab-shstrtab.s

 # VALIDATE: Name: .strtab
 
 ## Case 1: basic copy.
 # RUN: llvm-objcopy %t.o %t.basic
 # RUN: llvm-readobj --section-headers --symbols %t.basic \
 # RUN:   | FileCheck %s --check-prefix=BASIC --implicit-check-not=.shstrtab
 
 # BASIC: Sections [
-# BASIC:   Name: .foo (
 # BASIC:   Name: .strtab (
+# BASIC:   Name: .foo (
 # BASIC: Symbols [
 # BASIC:   Name: foo (
 
 ## Case 2: renaming a section.
 # RUN: llvm-objcopy %t.o %t.rename-section --rename-section .foo=.oof
 # RUN: llvm-readobj --section-headers --symbols %t.rename-section \
 # RUN:   | FileCheck %s --check-prefix=SECTION-RENAME --implicit-check-not=.shstrtab
 
 # SECTION-RENAME: Sections [
-# SECTION-RENAME:   Name: .oof (
 # SECTION-RENAME:   Name: .strtab (
+# SECTION-RENAME:   Name: .oof (
 # SECTION-RENAME: Symbols [
 # SECTION-RENAME:   Name: foo (
 
 ## Case 3: renaming a symbol.
 # RUN: llvm-objcopy %t.o %t.redefine-symbol --redefine-sym foo=oof
 # RUN: llvm-readobj --section-headers --symbols %t.redefine-symbol \
 # RUN:   | FileCheck %s --check-prefix=SYMBOL-RENAME --implicit-check-not=.shstrtab
 
 # SYMBOL-RENAME: Sections [
-# SYMBOL-RENAME:   Name: .foo (
 # SYMBOL-RENAME:   Name: .strtab (
+# SYMBOL-RENAME:   Name: .foo (
 # SYMBOL-RENAME: Symbols [
 # SYMBOL-RENAME:   Name: oof (
 
 ## Case 4: removing a section.
 # RUN: llvm-objcopy %t.o %t.remove-section -R .foo
 # RUN: llvm-readobj --section-headers --symbols %t.remove-section \
 # RUN:   | FileCheck %s --check-prefix=SECTION-REMOVE --implicit-check-not=.shstrtab --implicit-check-not=.foo
 
 # SECTION-REMOVE: Sections [
 # SECTION-REMOVE:   Name: .strtab (
 # SECTION-REMOVE: Symbols [
 # SECTION-REMOVE:   Name: foo (
 
 ## Case 5: removing a symbol.
 # RUN: llvm-objcopy %t.o %t.remove-symbol -N foo
 # RUN: llvm-readobj --section-headers --symbols %t.remove-symbol \
 # RUN:   | FileCheck %s --check-prefix=SYMBOL-REMOVE --implicit-check-not=.shstrtab --implicit-check-not="Name: foo"
 
 # SYMBOL-REMOVE: Sections [
-# SYMBOL-REMOVE:   Name: .foo (
 # SYMBOL-REMOVE:   Name: .strtab (
+# SYMBOL-REMOVE:   Name: .foo (
 # SYMBOL-REMOVE: Symbols [
 
 ## Case 6: adding a section.
 # RUN: llvm-objcopy %t.o %t.add-section --add-section .bar=%s
 # RUN: llvm-readobj --section-headers --symbols %t.add-section \
 # RUN:   | FileCheck %s --check-prefix=SECTION-ADD --implicit-check-not=.shstrtab
 
 # SECTION-ADD: Sections [
-# SECTION-ADD:   Name: .foo (
 # SECTION-ADD:   Name: .strtab (
+# SECTION-ADD:   Name: .foo (
 # SECTION-ADD:   Name: .bar (
 # SECTION-ADD: Symbols [
 # SECTION-ADD:   Name: foo (
 
 ## Case 7: adding a symbol.
 # RUN: llvm-objcopy %t.o %t.add-symbol --add-symbol bar=0x1234
 # RUN: llvm-readobj --section-headers --symbols %t.add-symbol \
 # RUN:   | FileCheck %s --check-prefix=SYMBOL-ADD --implicit-check-not=.shstrtab
 
 # SYMBOL-ADD: Sections [
-# SYMBOL-ADD:   Name: .foo (
 # SYMBOL-ADD:   Name: .strtab (
+# SYMBOL-ADD:   Name: .foo (
 # SYMBOL-ADD: Symbols [
 # SYMBOL-ADD:   Name: foo (
 # SYMBOL-ADD:   Name: bar (
 
 ## Case 8: removing all symbols.
 # RUN: llvm-objcopy %t.o %t.strip-all --strip-all
 # RUN: llvm-readobj --section-headers --symbols %t.strip-all \
 # RUN:   | FileCheck %s --check-prefix=STRIP-ALL --implicit-check-not=.shstrtab
 
 # STRIP-ALL:      Sections [
-# STRIP-ALL:        Name: .foo (
 # STRIP-ALL:        Name: .strtab (
+# STRIP-ALL:        Name: .foo (
 # STRIP-ALL:      Symbols [
 # STRIP-ALL-NEXT: ]
 
 .section .foo,"a",@progbits
 foo = 0x4321

llvm/test/tools/llvm-objcopy/ELF/strip-dwo-groups.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy --strip-dwo %t
-# RUN: llvm-readobj --symbols -S --section-groups %t | FileCheck %s
+# RUN: llvm-readobj --symbols -S --section-groups %t | \
+# RUN:   FileCheck %s --implicit-check-not=.debug_
 
-## `llvm-objcopy --strip-dwo` strips out dwo sections, as a result, the index of 
+## `llvm-objcopy --strip-dwo` strips out dwo sections, as a result, the index of
 ## the symbol table, the indices of the symbols and the indices of the sections
-## which go after the removed ones will change. Consequently, the fields 
-## Link, Info and the content of .group need to be updated.
+## which go after the removed ones will change. Consequently, the fields Link,
+## Info and the content of .group need to be updated.
 
-# CHECK-NOT: .debug_
+## Note. 'Signature' is generated using 'Link' and 'Info', so checking it
+## validates updating these fields.
 
 # CHECK:      Groups {
 # CHECK-NEXT:  Group {
-# CHECK-NEXT:   Name: .group (1)
-# CHECK-NEXT:   Index: 1{{$}}
-# CHECK-NEXT:   Link: 6
-# CHECK-NEXT:   Info: 2
-# CHECK-NEXT:   Type: COMDAT (0x1)
+# CHECK-NEXT:   Name: .group
+# CHECK-NEXT:   Index:
+# CHECK-NEXT:   Link:
+# CHECK-NEXT:   Info:
+# CHECK-NEXT:   Type:
 # CHECK-NEXT:   Signature: group1
 # CHECK-NEXT:   Section(s) in group [
-# CHECK-NEXT:     .text.group1 (3)
+# CHECK-NEXT:     .text.group1
 # CHECK-NEXT:   ]
 
-# CHECK-NOT: .debug_
-
-# CHECK:      Name: .group (1)
-# CHECK-NEXT: Index: 2{{$}}
-# CHECK-NEXT: Link: 6
-# CHECK-NEXT: Info: 1
-# CHECK-NEXT: Type: COMDAT (0x1)
-# CHECK-NEXT: Signature: group2
-# CHECK-NEXT: Section(s) in group [
-# CHECK-NEXT:   .text.group2 (4)
-# CHECK-NEXT:   .rela.text.group2 (5)
-# CHECK-NEXT: ]
+# CHECK:        Name: .group
+# CHECK-NEXT:   Index:
+# CHECK-NEXT:   Link:
+# CHECK-NEXT:   Info:
+# CHECK-NEXT:   Type:
+# CHECK-NEXT:   Signature: group2
+# CHECK-NEXT:   Section(s) in group [
+# CHECK-NEXT:     .text.group2
+# CHECK-NEXT:     .rela.text.group2
+# CHECK-NEXT:   ]
 
-# CHECK-NOT: .debug_
-
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .debug_before.dwo

llvm/test/tools/llvm-objcopy/ELF/strip-dwo-inplace.test

 # RUN: cp %p/Inputs/dwarf.dwo %t
 # RUN: llvm-objcopy --strip-dwo %t
 # RUN: llvm-readobj --file-headers --sections %t | FileCheck %s
 
 CHECK:     SectionHeaderCount: 24
 
+CHECK:    Name: .strtab
 CHECK:    Name: .text
+CHECK:    Name: .rela.text
 CHECK:    Name: .rodata.str1.1
 CHECK:    Name: .debug_str
 CHECK:    Name: .debug_abbrev
 CHECK:    Name: .debug_info
+CHECK:    Name: .rela.debug_info
 CHECK:    Name: .debug_ranges
 CHECK:    Name: .debug_macinfo
 CHECK:    Name: .debug_addr
+CHECK:    Name: .rela.debug_addr
 CHECK:    Name: .debug_pubnames
+CHECK:    Name: .rela.debug_pubnames
 CHECK:    Name: .debug_pubtypes
+CHECK:    Name: .rela.debug_pubtypes
 CHECK:    Name: .comment
 CHECK:    Name: .note.GNU-stack
 CHECK:    Name: .debug_frame
-CHECK:    Name: .debug_line
-CHECK:    Name: .symtab
-CHECK:    Name: .rela.text
-CHECK:    Name: .rela.debug_info
-CHECK:    Name: .rela.debug_addr
-CHECK:    Name: .rela.debug_pubnames
-CHECK:    Name: .rela.debug_pubtypes
 CHECK:    Name: .rela.debug_frame
+CHECK:    Name: .debug_line
 CHECK:    Name: .rela.debug_line
-CHECK:    Name: .strtab
+CHECK:    Name: .symtab

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

 }
 
 static bool isCompressable(const SectionBase &Sec) {
   return !(Sec.Flags & ELF::SHF_COMPRESSED) &&
          StringRef(Sec.Name).startswith(".debug");
 }
 
 static Error replaceDebugSections(
-    Object &Obj, SectionPred &RemovePred,
-    function_ref<bool(const SectionBase &)> ShouldReplace,
+    Object &Obj, function_ref<bool(const SectionBase &)> ShouldReplace,
     function_ref<Expected<SectionBase *>(const SectionBase *)> AddSection) {
   // Build a list of the debug sections we are going to replace.
   // We can't call `AddSection` while iterating over sections,
   // because it would mutate the sections array.
   SmallVector<SectionBase *, 13> ToReplace;
   for (auto &Sec : Obj.sections())
     if (ShouldReplace(Sec))
       ToReplace.push_back(&Sec);
 
   // Build a mapping from original section to a new one.
   DenseMap<SectionBase *, SectionBase *> FromTo;
   for (SectionBase *S : ToReplace) {
     Expected<SectionBase *> NewSection = AddSection(S);
     if (!NewSection)
       return NewSection.takeError();
 
     FromTo[S] = *NewSection;
   }
 
-  // Now we want to update the target sections of relocation
-  // sections. Also we will update the relocations themselves
-  // to update the symbol references.
-  for (auto &Sec : Obj.sections())
-    Sec.replaceSectionReferences(FromTo);
-
-  RemovePred = [ShouldReplace, RemovePred](const SectionBase &Sec) {
-    return ShouldReplace(Sec) || RemovePred(Sec);
-  };
-
-  return Error::success();
+  return Obj.replaceSections(FromTo);
 }
 
 static bool isUnneededSymbol(const Symbol &Sym) {
   return !Sym.Referenced &&
          (Sym.Binding == STB_LOCAL || Sym.getShndx() == SHN_UNDEF) &&
          Sym.Type != STT_SECTION;
 }
 
if ((!Config.SymbolsToKeep.empty() || Config.KeepFileSymbols) &&
       Obj.SymbolTable && !Obj.SymbolTable->empty()) {
     RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
       if (&Sec == Obj.SymbolTable || &Sec == Obj.SymbolTable->getStrTab())
         return false;
       return RemovePred(Sec);
     };
   }
 
+  if (Error E = Obj.removeSections(Config.AllowBrokenLinks, RemovePred))
+    return E;
+
   if (Config.CompressionType != DebugCompressionType::None) {
     if (Error Err = replaceDebugSections(
-            Obj, RemovePred, isCompressable,
+            Obj, isCompressable,
             [&Config, &Obj](const SectionBase *S) -> Expected<SectionBase *> {
               Expected<CompressedSection> NewSection =
                   CompressedSection::create(*S, Config.CompressionType);
               if (!NewSection)
                 return NewSection.takeError();
 
               return &Obj.addSection<CompressedSection>(std::move(*NewSection));
             }))
       return Err;
   } else if (Config.DecompressDebugSections) {
     if (Error Err = replaceDebugSections(
-            Obj, RemovePred,
+            Obj,
             [](const SectionBase &S) { return isa<CompressedSection>(&S); },
             [&Obj](const SectionBase *S) {
               const CompressedSection *CS = cast<CompressedSection>(S);
               return &Obj.addSection<DecompressedSection>(*CS);
             }))
       return Err;
   }
 
-  return Obj.removeSections(Config.AllowBrokenLinks, RemovePred);
+  return Error::success();
 }
 
 // Add symbol to the Object symbol table with the specified properties.
 static void addSymbol(Object &Obj, const NewSymbolInfo &SymInfo,
                       uint8_t DefaultVisibility) {
   SectionBase *Sec = Obj.findSection(SymInfo.SectionName);
   uint64_t Value = Sec ? Sec->Addr + SymInfo.Value : SymInfo.Value;
 

llvm/tools/llvm-objcopy/ELF/Object.h

public:
   uint32_t Flags;
 
   bool HadShdrs = true;
   bool MustBeRelocatable = false;
   StringTableSection *SectionNames = nullptr;
   SymbolTableSection *SymbolTable = nullptr;
   SectionIndexSection *SectionIndexTable = nullptr;
 
-  void sortSections();
   SectionTableRef sections() const { return SectionTableRef(Sections); }
   iterator_range<
       filter_iterator<pointee_iterator<std::vector<SecPtr>::const_iterator>,
                       decltype(&sectionIsAlloc)>>
   allocSections() const {
     return make_filter_range(make_pointee_range(Sections), sectionIsAlloc);
   }
 
   SectionBase *findSection(StringRef Name) {
     auto SecIt =
         find_if(Sections, [&](const SecPtr &Sec) { return Sec->Name == Name; });
     return SecIt == Sections.end() ? nullptr : SecIt->get();
   }
   SectionTableRef removedSections() { return SectionTableRef(RemovedSections); }
 
   ConstRange<Segment> segments() const { return make_pointee_range(Segments); }
 
   Error removeSections(bool AllowBrokenLinks,
                        std::function<bool(const SectionBase &)> ToRemove);
+  Error replaceSections(const DenseMap<SectionBase *, SectionBase *> &FromTo);
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   template <class T, class... Ts> T &addSection(Ts &&... Args) {
     auto Sec = std::make_unique<T>(std::forward<Ts>(Args)...);
     auto Ptr = Sec.get();
     MustBeRelocatable |= isa<RelocationSection>(*Ptr);
     Sections.emplace_back(std::move(Sec));
     Ptr->Index = Sections.size();
     return *Ptr;

llvm/tools/llvm-objcopy/ELF/Object.cpp

for (const IHexRecord &R : Records) {
     uint64_t RecAddr;
     switch (R.Type) {
     case IHexRecord::Data:
       // Ignore empty data records
       if (R.HexData.empty())
         continue;
       RecAddr = R.Addr + SegmentAddr + BaseAddr;
       if (!Section || Section->Addr + Section->Size != RecAddr) {
-        // OriginalOffset field is only used to sort section properly, so
-        // instead of keeping track of real offset in IHEX file, and as
-        // Object::sortSections() uses llvm::stable_sort(), we can just set to a
-        // constant (zero).
+        // OriginalOffset field is only used to sort sections before layout, so
+        // instead of keeping track of real offsets in IHEX file, and as
+        // layoutSections() and layoutSectionsForOnlyKeepDebug() use
+        // llvm::stable_sort(), we can just set it to a constant (zero).
         Section = &Obj->addSection<OwnedDataSection>(
             ".sec" + std::to_string(SecNo), RecAddr,
             ELF::SHF_ALLOC | ELF::SHF_WRITE, 0);
         SecNo++;
       }
       Section->appendHexData(R.HexData);
       break;
     case IHexRecord::EndOfFile:
Error Object::removeSections(
   // Transfer removed sections into the Object RemovedSections container for use
   // later.
   std::move(Iter, Sections.end(), std::back_inserter(RemovedSections));
   // Now finally get rid of them all together.
   Sections.erase(Iter, std::end(Sections));
   return Error::success();
 }
 
+Error Object::replaceSections(
+    const DenseMap<SectionBase *, SectionBase *> &FromTo) {
+  auto SectionIndexLess = [](const SecPtr &Lhs, const SecPtr &Rhs) {
+    return Lhs->Index < Rhs->Index;
+  };
+  assert(llvm::is_sorted(Sections, SectionIndexLess) &&
+         "Sections are expected to be sorted by Index");
+  // Set indices of new sections so that they can be later sorted into positions
+  // of removed ones.
+  for (auto &I : FromTo)
+    I.second->Index = I.first->Index;
+
+  // Notify all sections about the replacement.
+  for (auto &Sec : Sections)
+    Sec->replaceSectionReferences(FromTo);
+
+  if (Error E = removeSections(
+          /*AllowBrokenLinks=*/false,
+          [=](const SectionBase &Sec) { return FromTo.count(&Sec) > 0; }))
+    return E;
+  llvm::sort(Sections, SectionIndexLess);
+  return Error::success();
+}
+
 Error Object::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
   if (SymbolTable)
     for (const SecPtr &Sec : Sections)
       if (Error E = Sec->removeSymbols(ToRemove))
         return E;
   return Error::success();
 }
 
if (Error Err = SymTab.initialize(sections()))
     return Err;
   SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0);
 
   SymbolTable = &SymTab;
 
   return Error::success();
 }
 
-void Object::sortSections() {
-  // Use stable_sort to maintain the original ordering as closely as possible.
-  llvm::stable_sort(Sections, [](const SecPtr &A, const SecPtr &B) {
-    // Put SHT_GROUP sections first, since group section headers must come
-    // before the sections they contain. This also matches what GNU objcopy
-    // does.
-    if (A->Type != B->Type &&
-        (A->Type == ELF::SHT_GROUP || B->Type == ELF::SHT_GROUP))
-      return A->Type == ELF::SHT_GROUP;
-    // For all other sections, sort by offset order.
-    return A->OriginalOffset < B->OriginalOffset;
-  });
-}
-
 // Orders segments such that if x = y->ParentSegment then y comes before x.
 static void orderSegments(std::vector<Segment *> &Segments) {
   llvm::stable_sort(Segments, compareSegmentsByOffset);
 }
 
 // This function finds a consistent layout for a list of segments starting from
 // an Offset. It assumes that Segments have been sorted by orderSegments and
 // returns an Offset one past the end of the last segment.

 template <class Range>
 static uint64_t layoutSections(Range Sections, uint64_t Offset) {
   // Now the offset of every segment has been set we can assign the offsets
   // of each section. For sections that are covered by a segment we should use
   // the segment's original offset and the section's original offset to compute
   // the offset from the start of the segment. Using the offset from the start
   // of the segment we can assign a new offset to the section. For sections not
   // covered by segments we can just bump Offset to the next valid location.
+  // While it is not necessary, layout the sections in the order based on their
+  // original offsets to resemble the input file as close as possible.
+  std::vector<SectionBase *> OutOfSegmentSections;
   uint32_t Index = 1;
   for (auto &Sec : Sections) {
     Sec.Index = Index++;
     if (Sec.ParentSegment != nullptr) {
       auto Segment = *Sec.ParentSegment;
       Sec.Offset =
           Segment.Offset + (Sec.OriginalOffset - Segment.OriginalOffset);
-    } else {
-      Offset = alignTo(Offset, Sec.Align == 0 ? 1 : Sec.Align);
-      Sec.Offset = Offset;
-      if (Sec.Type != SHT_NOBITS)
-        Offset += Sec.Size;
-    }
+    } else
+      OutOfSegmentSections.push_back(&Sec);
+
+  llvm::stable_sort(OutOfSegmentSections,
+                    [](const SectionBase *Lhs, const SectionBase *Rhs) {
+                      return Lhs->OriginalOffset < Rhs->OriginalOffset;
+                    });
+  for (auto *Sec : OutOfSegmentSections) {
+    Offset = alignTo(Offset, Sec->Align == 0 ? 1 : Sec->Align);
+    Sec->Offset = Offset;
+    if (Sec->Type != SHT_NOBITS)
+      Offset += Sec->Size;
   }
   return Offset;
 }
 
 // Rewrite sh_offset after some sections are changed to SHT_NOBITS and thus
 // occupy no space in the file.
 static uint64_t layoutSectionsForOnlyKeepDebug(Object &Obj, uint64_t Off) {
+  // The layout algorithm requires the sections to be handled in the order of
+  // their offsets in the input file, at least inside segments.
+  std::vector<SectionBase *> Sections;
+  Sections.reserve(Obj.sections().size());
   uint32_t Index = 1;
   for (auto &Sec : Obj.sections()) {
     Sec.Index = Index++;
+    Sections.push_back(&Sec);
+  }
+  llvm::stable_sort(Sections,
+                    [](const SectionBase *Lhs, const SectionBase *Rhs) {
+                      return Lhs->OriginalOffset < Rhs->OriginalOffset;
+                    });
 
-    auto *FirstSec = Sec.ParentSegment && Sec.ParentSegment->Type == PT_LOAD
-                         ? Sec.ParentSegment->firstSection()
+  for (auto *Sec : Sections) {
+    auto *FirstSec = Sec->ParentSegment && Sec->ParentSegment->Type == PT_LOAD
+                         ? Sec->ParentSegment->firstSection()
                          : nullptr;
 
     // The first section in a PT_LOAD has to have congruent offset and address
     // modulo the alignment, which usually equals the maximum page size.
-    if (FirstSec && FirstSec == &Sec)
-      Off = alignTo(Off, Sec.ParentSegment->Align, Sec.Addr);
+    if (FirstSec && FirstSec == Sec)
+      Off = alignTo(Off, Sec->ParentSegment->Align, Sec->Addr);
 
     // sh_offset is not significant for SHT_NOBITS sections, but the congruence
     // rule must be followed if it is the first section in a PT_LOAD. Do not
     // advance Off.
-    if (Sec.Type == SHT_NOBITS) {
-      Sec.Offset = Off;
+    if (Sec->Type == SHT_NOBITS) {
+      Sec->Offset = Off;
       continue;
     }
 
     if (!FirstSec) {
       // FirstSec being nullptr generally means that Sec does not have the
       // SHF_ALLOC flag.
-      Off = Sec.Align ? alignTo(Off, Sec.Align) : Off;
-    } else if (FirstSec != &Sec) {
+      Off = Sec->Align ? alignTo(Off, Sec->Align) : Off;
+    } else if (FirstSec != Sec) {
       // The offset is relative to the first section in the PT_LOAD segment. Use
       // sh_offset for non-SHF_ALLOC sections.
-      Off = Sec.OriginalOffset - FirstSec->OriginalOffset + FirstSec->Offset;
+      Off = Sec->OriginalOffset - FirstSec->OriginalOffset + FirstSec->Offset;
     }
-    Sec.Offset = Off;
-    Off += Sec.Size;
+    Sec->Offset = Off;
+    Off += Sec->Size;
   }
   return Off;
 }
 
 // Rewrite p_offset and p_filesz of non-PT_PHDR segments after sh_offset values
 // have been updated.
 static uint64_t layoutSegmentsForOnlyKeepDebug(std::vector<Segment *> &Segments,
                                                uint64_t HdrEnd) {
template <class ELFT> Error ELFWriter<ELFT>::finalize() {
   // to do that.
   if (Obj.SectionNames == nullptr && WriteSectionHeaders)
     return createStringError(llvm::errc::invalid_argument,
                              "cannot write section header table because "
                              "section header string table was removed");
 
   if (Error E = removeUnneededSections(Obj))
     return E;
-  Obj.sortSections();
 
   // We need to assign indexes before we perform layout because we need to know
   // if we need large indexes or not. We can assign indexes first and check as
   // we go to see if we will actully need large indexes.
   bool NeedsLargeIndexes = false;
   if (Obj.sections().size() >= SHN_LORESERVE) {
     SectionTableRef Sections = Obj.sections();
     // Sections doesn't include the null section header, so account for this