[yaml2obj/obj2yaml/llvm-readobj] Support SHF_GNU_RETAIN

[MaskRay]

Summary

In binutils, the flag is defined for ELFOSABI_GNU and ELFOSABI_FREEBSD.
It can be used to mark a section as a GC root.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

97

Since we don't inspect the OSABI value, I'd just omit this for now. If in the future we choose to do so, we should use a macro to generate this output with and without this OSABI value, so that we can show it being recognised/not recognised as appropriate.

On the other hand, should we inspect the value from the beginning?

129

Why the 0x800 flag?

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

129

To check that the key 'R' on the right of 'C'...

[MaskRay]

comment

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

3494

https://sourceware.org/pipermail/binutils/2021-January/115151.html

The look will be similar to readelf -S.

SHF_GNU_MBIND seems unuseful and LLVM does not support it, so I'll not add it.

[jhenderson]

LGTM.

[MaskRay]

Move "R (retain)" to the left of "p" (this matches GNU)

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHF_GROUP = 0x200U,
 
   // This section holds Thread-Local Storage.
   SHF_TLS = 0x400U,
 
   // Identifies a section containing compressed data.
   SHF_COMPRESSED = 0x800U,
 
+  // This section should not be garbage collected by the linker.
+  SHF_GNU_RETAIN = 0x200000,
+
   // This section is excluded from the final executable or shared library.
   SHF_EXCLUDE = 0x80000000U,
 
   // Start of target-specific flags.
 
   SHF_MASKOS = 0x0ff00000,
 
   // Bits indicating processor-specific flags.

llvm/lib/ObjectYAML/ELFYAML.cpp

#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
   BCase(SHF_MERGE);
   BCase(SHF_STRINGS);
   BCase(SHF_INFO_LINK);
   BCase(SHF_LINK_ORDER);
   BCase(SHF_OS_NONCONFORMING);
   BCase(SHF_GROUP);
   BCase(SHF_TLS);
   BCase(SHF_COMPRESSED);
+  BCase(SHF_GNU_RETAIN);
   switch (Object->getMachine()) {
   case ELF::EM_ARM:
     BCase(SHF_ARM_PURECODE);
     break;
   case ELF::EM_HEXAGON:
     BCase(SHF_HEX_GPREL);
     break;
   case ELF::EM_MIPS:

llvm/test/tools/llvm-readobj/ELF/gnu-sections.test

 # ELF32-NEXT:  [ 5] .bss              NOBITS          00000000 000038 000000 00  WA  0   0  4
 # ELF32-NEXT:  [ 6] .symtab           SYMTAB          00000000 000038 000020 10      7   2  8
 # ELF32-NEXT:  [ 7] .strtab           STRTAB          00000000 000058 000007 00      0   0  1
 # ELF32-NEXT:  [ 8] .shstrtab         STRTAB          00000000 00005f 00003b 00      0   0  1
 # ELF32-NEXT:Key to Flags:
 # ELF32-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
 # ELF32-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
 # ELF32-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
-# ELF32-NEXT:  p (processor specific)
+# ELF32-NEXT:  R (retain), p (processor specific)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS[[BITS=64]]
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_GNU
   Type:    ET_REL
   Machine: [[MACHINE=EM_NONE]]

 # ELF64-NEXT:  [ 5] .bss              NOBITS          0000000000000000 000048 000000 00  WA  0   0  4
 # ELF64-NEXT:  [ 6] .symtab           SYMTAB          0000000000000000 000048 000030 18      7   2  8
 # ELF64-NEXT:  [ 7] .strtab           STRTAB          0000000000000000 000078 000007 00      0   0  1
 # ELF64-NEXT:  [ 8] .shstrtab         STRTAB          0000000000000000 00007f 00003b 00      0   0  1
 # ELF64-NEXT:Key to Flags:
 # ELF64-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
 # ELF64-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
 # ELF64-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
-# ELF64-NEXT:  l (large), p (processor specific)
+# ELF64-NEXT:  R (retain), l (large), p (processor specific)
 
 ## For an EM_ARM target we print "y" for the SHF_ARM_PURECODE section flag.
 ## Check we mention it in the flag key.
 
 # RUN: yaml2obj -DMACHINE=EM_ARM %s -o %t-arm.o
 # RUN: llvm-readelf -S %t-arm.o | FileCheck %s --check-prefix=ARM --strict-whitespace --match-full-lines
 
 #      ARM:Key to Flags:
 # ARM-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
 # ARM-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
 # ARM-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
-# ARM-NEXT:  y (purecode), p (processor specific)
+# ARM-NEXT:  R (retain), y (purecode), p (processor specific)

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

 ## Here we test how OS and processor specific flags are dumped.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -S %t.o | FileCheck --check-prefix=OS-PROC-LLVM %s
 # RUN: llvm-readelf -S %t.o | FileCheck --check-prefix=OS-PROC-GNU %s
 
 # OS-PROC-LLVM:      Name: .os.flags.low
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0x100000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .os.flags.high
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xFE00000)
+# OS-PROC-LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .os.flags.mask
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xFF00000)
+# OS-PROC-LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .proc.flags.low
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0x10000000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .proc.flags.high
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xE0000000)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .proc.flags.mask
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xF0000000)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .both.flags.low
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0x10100000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .both.flags.high
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xEFE00000)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .both.flags.mask
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xFFF00000)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .exclude
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0x80000000)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # OS-PROC-LLVM-NEXT: ]
 # OS-PROC-LLVM:      Name: .all.possible
 # OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
 # OS-PROC-LLVM-NEXT: Flags [ (0xFFFFFFFF)
 # OS-PROC-LLVM-NEXT:   SHF_ALLOC (0x2)
 # OS-PROC-LLVM-NEXT:   SHF_COMPRESSED (0x800)
 # OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # OS-PROC-LLVM-NEXT:   SHF_EXECINSTR (0x4)
+# OS-PROC-LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # OS-PROC-LLVM-NEXT:   SHF_GROUP (0x200)
 # OS-PROC-LLVM-NEXT:   SHF_INFO_LINK (0x40)
 # OS-PROC-LLVM-NEXT:   SHF_LINK_ORDER (0x80)
 # OS-PROC-LLVM-NEXT:   SHF_MERGE (0x10)
 # OS-PROC-LLVM-NEXT:   SHF_OS_NONCONFORMING (0x100)
 # OS-PROC-LLVM-NEXT:   SHF_STRINGS (0x20)
 # OS-PROC-LLVM-NEXT:   SHF_TLS (0x400)
 # OS-PROC-LLVM-NEXT:   SHF_WRITE (0x1)
 # OS-PROC-LLVM-NEXT: ]
 
 # OS-PROC-GNU:      Section Headers:
 # OS-PROC-GNU-NEXT:  [Nr] Name                   Type     Address          Off    Size   ES Flg            Lk Inf Al
 # OS-PROC-GNU-NEXT:  [ 0]                        NULL     0000000000000000 000000 000000 00                0   0  0
 # OS-PROC-GNU-NEXT:  [ 1] .os.flags.low          PROGBITS 0000000000000000 000040 000000 00   o            0   0  0
-# OS-PROC-GNU-NEXT:  [ 2] .os.flags.high         PROGBITS 0000000000000000 000040 000000 00   o            0   0  0
+# OS-PROC-GNU-NEXT:  [ 2] .os.flags.high         PROGBITS 0000000000000000 000040 000000 00  Ro            0   0  0
 # OS-PROC-GNU-NEXT:  [ 3] .os.flags.mask         PROGBITS 0000000000000000 000040 000000 00   o            0   0  0
 # OS-PROC-GNU-NEXT:  [ 4] .proc.flags.low        PROGBITS 0000000000000000 000040 000000 00   p            0   0  0
 # OS-PROC-GNU-NEXT:  [ 5] .proc.flags.high       PROGBITS 0000000000000000 000040 000000 00   p            0   0  0
 # OS-PROC-GNU-NEXT:  [ 6] .proc.flags.mask       PROGBITS 0000000000000000 000040 000000 00   p            0   0  0
 # OS-PROC-GNU-NEXT:  [ 7] .both.flags.low        PROGBITS 0000000000000000 000040 000000 00  op            0   0  0
-# OS-PROC-GNU-NEXT:  [ 8] .both.flags.high       PROGBITS 0000000000000000 000040 000000 00  op            0   0  0
+# OS-PROC-GNU-NEXT:  [ 8] .both.flags.high       PROGBITS 0000000000000000 000040 000000 00 Rop            0   0  0
 # OS-PROC-GNU-NEXT:  [ 9] .both.flags.mask       PROGBITS 0000000000000000 000040 000000 00  op            0   0  0
 # OS-PROC-GNU-NEXT:  [10] .exclude               PROGBITS 0000000000000000 000040 000000 00   E            0   0  0
 # OS-PROC-GNU-NEXT:  [11] .all.possible          PROGBITS 0000000000000000 000040 000000 00 WAXMSILOGTCopx 0   0  0
 
 ## Use an arbitrary EM_* machine type that does not have specific SHF_* OS/Processor
 ## flags to test what we dump when bits in the OS and processor specific ranges are set.
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:  .os.flags.low
     Type:  SHT_PROGBITS
     ShFlags: 0x00100000
   - Name:  .os.flags.high
     Type:  SHT_PROGBITS
     ShFlags: 0x0FE00000
   - Name:  .os.flags.mask
     Type:  SHT_PROGBITS
- Name:  .both.flags.high
     ShFlags: 0xEFE00000
   - Name:  .both.flags.mask
     Type:  SHT_PROGBITS
     ShFlags: 0xFFF00000
 ## SHF_MASKPROC has a value of 0xf0000000, SHF_EXCLUDE has a value of
 ## 0x80000000. When SHF_EXCLUDE is mixed with other processor specific
 ## flags, GNU readelf does not necessarily print "E", because it handles
 ## the SHF_MASKPROC mask first. It only prints "E" when there are no other
 ## processor flags set. Check llvm-readelf output matches GNU.
   - Name:  .exclude
     Type:  SHT_PROGBITS
     ShFlags: 0x80000000
 ## Set all possible flags to test where we print 'o' and 'p' letters.
   - Name:  .all.possible
     Type:  SHT_PROGBITS
     ShFlags: 0xFFFFFFFF

llvm/test/tools/llvm-readobj/ELF/section-flags.test

 ## Check how we dump regular ELF section flags.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -S %t.o | FileCheck --check-prefix=LLVM %s
 # RUN: llvm-readelf -S %t.o | FileCheck --check-prefix=GNU %s
 
 # LLVM:      Name: allflags
 # LLVM-NEXT: Type: SHT_PROGBITS
-# LLVM-NEXT: Flags [ (0x80000FF7)
+# LLVM-NEXT: Flags [ (0x80200FF7)
 # LLVM-NEXT:   SHF_ALLOC (0x2)
 # LLVM-NEXT:   SHF_COMPRESSED (0x800)
 # LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # LLVM-NEXT:   SHF_EXECINSTR (0x4)
+# LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
 # LLVM-NEXT:   SHF_GROUP (0x200)
 # LLVM-NEXT:   SHF_INFO_LINK (0x40)
 # LLVM-NEXT:   SHF_LINK_ORDER (0x80)
 # LLVM-NEXT:   SHF_MERGE (0x10)
 # LLVM-NEXT:   SHF_OS_NONCONFORMING (0x100)
 # LLVM-NEXT:   SHF_STRINGS (0x20)
 # LLVM-NEXT:   SHF_TLS (0x400)
 # LLVM-NEXT:   SHF_WRITE (0x1)

 # LLVM-NEXT: ]
 
 # LLVM:      Name: compressed
 # LLVM-NEXT: Type: SHT_PROGBITS
 # LLVM-NEXT: Flags [ (0x800)
 # LLVM-NEXT:   SHF_COMPRESSED (0x800)
 # LLVM-NEXT: ]
 
+## SHF_GNU_RETAIN is defined in the OS-specific range, but we treat it generic
+## and allow it to be used with OSABI values other than GNU and FREEBSD.
+# LLVM:      Name: retain
+# LLVM-NEXT: Type: SHT_PROGBITS
+# LLVM-NEXT: Flags [ (0x200000)
+# LLVM-NEXT:   SHF_GNU_RETAIN (0x200000)
+# LLVM-NEXT: ]
+
 # LLVM:      Name: exclude
 # LLVM-NEXT: Type: SHT_PROGBITS
 # LLVM-NEXT: Flags [ (0x80000000)
 # LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
 # LLVM-NEXT: ]
 
 # LLVM:      Name: unknown
 # LLVM-NEXT: Type: SHT_PROGBITS
 # LLVM-NEXT: Flags [ (0xF0000)
 # LLVM-NEXT: ]
 
 # GNU: [Nr] Name          Type     Address          Off    Size   ES Flg          Lk Inf Al
-# GNU: [ 1] allflags      PROGBITS 0000000000000000 000040 000000 00 WAXMSILOGTCE 0   0  0
+# GNU: [ 1] allflags      PROGBITS 0000000000000000 000040 000000 00 WAXMSILOGTCRE 0   0  0
 # GNU: [ 2] noflags       PROGBITS 0000000000000000 000040 000000 00              0   0  0
 # GNU: [ 3] write         PROGBITS 0000000000000000 000040 000000 00 W            0   0  0
 # GNU: [ 4] alloc         PROGBITS 0000000000000000 000040 000000 00 A            0   0  0
 # GNU: [ 5] exec          PROGBITS 0000000000000000 000040 000000 00 X            0   0  0
 # GNU: [ 6] merge         PROGBITS 0000000000000000 000040 000000 00 M            0   0  0
 # GNU: [ 7] strings       PROGBITS 0000000000000000 000040 000000 00 S            0   0  0
 # GNU: [ 8] infolink      PROGBITS 0000000000000000 000040 000000 00 I            0   0  0
 # GNU: [ 9] linkorder     PROGBITS 0000000000000000 000040 000000 00 L            0   0  0
 # GNU: [10] nonconforming PROGBITS 0000000000000000 000040 000000 00 O            0   0  0
 # GNU: [11] group         PROGBITS 0000000000000000 000040 000000 00 G            0   0  0
 # GNU: [12] tls           PROGBITS 0000000000000000 000040 000000 00 T            0   0  0
 # GNU: [13] compressed    PROGBITS 0000000000000000 000040 000000 00 C            0   0  0
-# GNU: [14] exclude       PROGBITS 0000000000000000 000040 000000 00 E            0   0  0
-# GNU: [15] unknown       PROGBITS 0000000000000000 000040 000000 00 x            0   0  0
+# GNU: [14] retain        PROGBITS 0000000000000000 000040 000000 00 R            0   0  0
+# GNU: [15] exclude       PROGBITS 0000000000000000 000040 000000 00 E            0   0  0
+# GNU: [16] unknown       PROGBITS 0000000000000000 000040 000000 00 x            0   0  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
   Flags: []
 Sections:
   - Name:  allflags
     Type:  SHT_PROGBITS
     Flags: [ SHF_WRITE, SHF_ALLOC, SHF_EXECINSTR, SHF_MERGE,
             SHF_STRINGS, SHF_INFO_LINK, SHF_LINK_ORDER, SHF_OS_NONCONFORMING,
-            SHF_GROUP, SHF_TLS, SHF_COMPRESSED, SHF_EXCLUDE ]
+            SHF_GROUP, SHF_TLS, SHF_COMPRESSED, SHF_GNU_RETAIN, SHF_EXCLUDE ]
   - Name:  noflags
     Type:  SHT_PROGBITS
     Flags: [ ]
   - Name:  write
     Type:  SHT_PROGBITS
     Flags: [ SHF_WRITE ]
   - Name:  alloc
     Type:  SHT_PROGBITS
- Name:  group
     Type:  SHT_PROGBITS
     Flags: [ SHF_GROUP ]
   - Name:  tls
     Type:  SHT_PROGBITS
     Flags: [ SHF_TLS ]
   - Name:  compressed
     Type:  SHT_PROGBITS
     Flags: [ SHF_COMPRESSED ]
+  - Name:  retain
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_GNU_RETAIN ]
   - Name:  exclude
     Type:  SHT_PROGBITS
     Flags: [ SHF_EXCLUDE ]
   - Name:  unknown
     Type:  SHT_PROGBITS
     ShFlags: 0x000f0000

llvm/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfSectionFlags[] = {
   ENUM_ENT(SHF_MERGE,            "M"),
   ENUM_ENT(SHF_STRINGS,          "S"),
   ENUM_ENT(SHF_INFO_LINK,        "I"),
   ENUM_ENT(SHF_LINK_ORDER,       "L"),
   ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
   ENUM_ENT(SHF_GROUP,            "G"),
   ENUM_ENT(SHF_TLS,              "T"),
   ENUM_ENT(SHF_COMPRESSED,       "C"),
+  ENUM_ENT(SHF_GNU_RETAIN,       "R"),
   ENUM_ENT(SHF_EXCLUDE,          "E"),
 };
 
 static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
   ENUM_ENT(XCORE_SHF_CP_SECTION, ""),
   ENUM_ENT(XCORE_SHF_DP_SECTION, "")
 };
 

 static void printSectionDescription(formatted_raw_ostream &OS,
                                     unsigned EMachine) {
   OS << "Key to Flags:\n";
   OS << "  W (write), A (alloc), X (execute), M (merge), S (strings), I "
         "(info),\n";
   OS << "  L (link order), O (extra OS processing required), G (group), T "
         "(TLS),\n";
   OS << "  C (compressed), x (unknown), o (OS specific), E (exclude),\n";
+  OS << "  R (retain)";
 
   if (EMachine == EM_X86_64)
-    OS << "  l (large), ";
+    OS << ", l (large)";
   else if (EMachine == EM_ARM)
-    OS << "  y (purecode), ";
-  else
-    OS << "  ";
+    OS << ", y (purecode)";
 
-  OS << "p (processor specific)\n";
+  OS << ", p (processor specific)\n";
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printSectionHeaders() {
   unsigned Bias = ELFT::Is64Bits ? 0 : 8;
   ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
   OS << "There are " << to_string(Sections.size())
      << " section headers, starting at offset "
      << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n";