MC, Object: Reserve a section type, SHT_LLVM_ODRTAB, for the ODR table.

[pcc]

Summary

This is part of the ODR checker proposal:
http://lists.llvm.org/pipermail/llvm-dev/2017-June/113820.html

It appears [1] that binutils' most recent section type number
allocations in the OS-specific range have been of the form 0x6fff47XX,
where 0x47 ('G') presumably stands for GNU. So I have taken the
bold step of using 0x6fff4c00, where 0x4c ('L') stands for LLVM. If
this seems reasonable I will contact gnu-gabi to reserve the entire
0x6fff4cXX range for LLVM.

[1] https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=elfcpp/elfcpp.h;h=cce40d41dedb281c2d8f41135250c2cc39162469;hb=HEAD#l369

[ruiu]

LGTM

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHT_SHLIB = 10,                  // Reserved.
   SHT_DYNSYM = 11,                 // Symbol table.
   SHT_INIT_ARRAY = 14,             // Pointers to initialization functions.
   SHT_FINI_ARRAY = 15,             // Pointers to termination functions.
   SHT_PREINIT_ARRAY = 16,          // Pointers to pre-init functions.
   SHT_GROUP = 17,                  // Section group.
   SHT_SYMTAB_SHNDX = 18,           // Indices for SHN_XINDEX entries.
   SHT_LOOS = 0x60000000,           // Lowest operating system-specific type.
+  SHT_LLVM_ODRTAB = 0x6fff4c00,    // LLVM ODR table.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,       // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,     // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,    // GNU version references.
   SHT_GNU_versym = 0x6fffffff,     // GNU symbol versions table.
   SHT_HIOS = 0x6fffffff,           // Highest operating system-specific type.
   SHT_LOPROC = 0x70000000,         // Lowest processor arch-specific type.
   // Fixme: All this is duplicated in MCSectionELF. Why??

llvm/lib/MC/MCParser/ELFAsmParser.cpp

if (TypeName.empty()) {
     else if (TypeName == "nobits")
       Type = ELF::SHT_NOBITS;
     else if (TypeName == "progbits")
       Type = ELF::SHT_PROGBITS;
     else if (TypeName == "note")
       Type = ELF::SHT_NOTE;
     else if (TypeName == "unwind")
       Type = ELF::SHT_X86_64_UNWIND;
+    else if (TypeName == "llvm_odrtab")
+      Type = ELF::SHT_LLVM_ODRTAB;
     else if (TypeName.getAsInteger(0, Type))
       return TokError("unknown section type");
   }
 
   if (UseLastGroup) {
     MCSectionSubPair CurrentSection = getStreamer().getCurrentSection();
     if (const MCSectionELF *Section =
             cast_or_null<MCSectionELF>(CurrentSection.first))

llvm/lib/MC/MCSectionELF.cpp

void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   else if (Type == ELF::SHT_PROGBITS)
     OS << "progbits";
   else if (Type == ELF::SHT_X86_64_UNWIND)
     OS << "unwind";
   else if (Type == ELF::SHT_MIPS_DWARF)
     // Print hex value of the flag while we do not have
     // any standard symbolic representation of the flag.
     OS << "0x7000001e";
+  else if (Type == ELF::SHT_LLVM_ODRTAB)
+    OS << "llvm_odrtab";
   else
     report_fatal_error("unsupported type 0x" + Twine::utohexstr(Type) +
                        " for section " + getSectionName());
 
   if (EntrySize) {
     assert(Flags & ELF::SHF_MERGE);
     OS << "," << EntrySize;
   }

llvm/lib/Object/ELF.cpp

switch (Type) {
     STRINGIFY_ENUM_CASE(ELF, SHT_REL);
     STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
     STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
     STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
     STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
+    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
   default:
     return "Unknown";
   }
 }

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(SHT_SHLIB);
   ECase(SHT_DYNSYM);
   ECase(SHT_INIT_ARRAY);
   ECase(SHT_FINI_ARRAY);
   ECase(SHT_PREINIT_ARRAY);
   ECase(SHT_GROUP);
   ECase(SHT_SYMTAB_SHNDX);
   ECase(SHT_LOOS);
+  ECase(SHT_LLVM_ODRTAB);
   ECase(SHT_GNU_ATTRIBUTES);
   ECase(SHT_GNU_HASH);
   ECase(SHT_GNU_verdef);
   ECase(SHT_GNU_verneed);
   ECase(SHT_GNU_versym);
   ECase(SHT_HIOS);
   ECase(SHT_LOPROC);
   switch (Object->Header.Machine) {

llvm/test/MC/ELF/section.s

 // CHECK:        Section {
 // CHECK:          Name: .tbss.foo
 // CHECK-NEXT:     Type: SHT_NOBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
+
+// Test SHT_LLVM_ODRTAB
+
+.section .odrtab,"e",@llvm_odrtab
+// ASM: .section .odrtab,"e",@llvm_odrtab
+
+// CHECK:        Section {
+// CHECK:          Name: .odrtab
+// CHECK-NEXT:     Type: SHT_LLVM_ODRTAB
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_EXCLUDE
+// CHECK-NEXT:     ]

llvm/tools/llvm-readobj/ELFDumper.cpp

std::string getSectionTypeString(unsigned Arch, unsigned Type) {
   case SHT_FINI_ARRAY:
     return "FINI_ARRAY";
   case SHT_PREINIT_ARRAY:
     return "PREINIT_ARRAY";
   case SHT_GROUP:
     return "GROUP";
   case SHT_SYMTAB_SHNDX:
     return "SYMTAB SECTION INDICES";
+  case SHT_LLVM_ODRTAB:
+    return "LLVM_ODRTAB";
   // FIXME: Parse processor specific GNU attributes
   case SHT_GNU_ATTRIBUTES:
     return "ATTRIBUTES";
   case SHT_GNU_HASH:
     return "GNU_HASH";
   case SHT_GNU_verdef:
     return "VERDEF";
   case SHT_GNU_verneed: