Index: llvm/include/llvm/ObjectYAML/ELFYAML.h =================================================================== --- llvm/include/llvm/ObjectYAML/ELFYAML.h +++ llvm/include/llvm/ObjectYAML/ELFYAML.h @@ -85,6 +85,14 @@ Optional SHStrNdx; }; +struct SecHdr { + StringRef Name; +}; + +struct SectionHeaderTable { + std::vector Sections; +}; + struct SectionName { StringRef Section; }; @@ -509,6 +517,7 @@ struct Object { FileHeader Header; + Optional SectionHeader; std::vector ProgramHeaders; // An object might contain output section descriptions as well as @@ -540,6 +549,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader) +LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SecHdr) LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry) @@ -671,6 +681,14 @@ static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr); }; +template <> struct MappingTraits { + static void mapping(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable); +}; + +template <> struct MappingTraits { + static void mapping(IO &IO, ELFYAML::SecHdr &SHdr); +}; + template <> struct MappingTraits { static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr); }; Index: llvm/lib/ObjectYAML/ELFEmitter.cpp =================================================================== --- llvm/lib/ObjectYAML/ELFEmitter.cpp +++ llvm/lib/ObjectYAML/ELFEmitter.cpp @@ -218,6 +218,8 @@ void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec); + DenseMap buildSectionHeaderReorderMap(); + BumpPtrAllocator StringAlloc; uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align, llvm::Optional Offset); @@ -310,18 +312,42 @@ Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0; Header.e_phnum = Doc.ProgramHeaders.size(); - Header.e_shentsize = - Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr); + if (Doc.Header.SHEntSize) + Header.e_shentsize = *Doc.Header.SHEntSize; + else if (!Doc.SectionHeader || !Doc.SectionHeader->Sections.empty()) + Header.e_shentsize = sizeof(Elf_Shdr); + else + Header.e_shentsize = 0; + // Align the start of the section header table, which is written after all // other sections to the end of the file. uint64_t SHOff = alignToOffset(CBA, sizeof(typename ELFT::uint), /*Offset=*/None); - Header.e_shoff = - Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff; - Header.e_shnum = - Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.getSections().size(); - Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx - : SN2I.get(".shstrtab"); + + if (Doc.Header.SHOff) + Header.e_shoff = *Doc.Header.SHOff; + else if (!Doc.SectionHeader) + Header.e_shoff = SHOff; + else if (Doc.SectionHeader->Sections.empty()) + Header.e_shoff = 0; + else + Header.e_shoff = SHOff; + + if (Doc.Header.SHNum) + Header.e_shnum = *Doc.Header.SHNum; + else if (!Doc.SectionHeader) + Header.e_shnum = Doc.getSections().size(); + else if (Doc.SectionHeader->Sections.empty()) + Header.e_shnum = 0; + else + Header.e_shnum = Doc.SectionHeader->Sections.size() + /*Null section*/ 1; + + if (Doc.Header.SHStrNdx) + Header.e_shstrndx = *Doc.Header.SHStrNdx; + else if (!Doc.SectionHeader || !Doc.SectionHeader->Sections.empty()) + Header.e_shstrndx = SN2I.get(".shstrtab"); + else + Header.e_shstrndx = 0; OS.write((const char *)&Header, sizeof(Header)); } @@ -1419,14 +1445,48 @@ Fill.Pattern->writeAsBinary(OS, Fill.Size - Written); } +template +DenseMap ELFState::buildSectionHeaderReorderMap() { + if (!Doc.SectionHeader || Doc.SectionHeader->Sections.empty()) + return DenseMap(); + + DenseMap Ret; + size_t SecNdx = 0; + StringSet<> Seen; + for (const ELFYAML::SecHdr &Hdr : Doc.SectionHeader->Sections) { + if (!Ret.insert({Hdr.Name, ++SecNdx}).second) + reportError("repeated section name: '" + Hdr.Name + + "' in the section header description"); + Seen.insert(Hdr.Name); + } + + for (const ELFYAML::Section *S : Doc.getSections()) { + // Ignore special first SHT_NULL section. + if (S == Doc.getSections().front()) + continue; + if (!Seen.count(S->Name)) + reportError("section header must list the '" + S->Name + "' section"); + Seen.erase(S->Name); + } + + for (const auto& It : Seen) + reportError("section header contains undefined section '" + It.getKey() + "'"); + return Ret; +} + template void ELFState::buildSectionIndex() { + // A YAML description can have an explicit section header declaration that allows + // to change the order of section headers. + DenseMap ReorderMap = buildSectionHeaderReorderMap(); + size_t SecNdx = -1; for (const std::unique_ptr &C : Doc.Chunks) { if (!isa(C.get())) continue; ++SecNdx; - if (!SN2I.addName(C->Name, SecNdx)) + size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(C->Name); + if (!SN2I.addName(C->Name, Index)) llvm_unreachable("buildSectionIndex() failed"); DotShStrtab.add(ELFYAML::dropUniqueSuffix(C->Name)); } Index: llvm/lib/ObjectYAML/ELFYAML.cpp =================================================================== --- llvm/lib/ObjectYAML/ELFYAML.cpp +++ llvm/lib/ObjectYAML/ELFYAML.cpp @@ -828,6 +828,15 @@ #undef BCase } +void MappingTraits::mapping(IO &IO, ELFYAML::SecHdr &SHdr) { + IO.mapRequired("Name", SHdr.Name); +} + +void MappingTraits::mapping( + IO &IO, ELFYAML::SectionHeaderTable &SectionHeader) { + IO.mapRequired("Sections", SectionHeader.Sections); +} + void MappingTraits::mapping(IO &IO, ELFYAML::FileHeader &FileHdr) { IO.mapRequired("Class", FileHdr.Class); @@ -1633,6 +1642,7 @@ IO.setContext(&Object); IO.mapTag("!ELF", true); IO.mapRequired("FileHeader", Object.Header); + IO.mapOptional("SectionHeaderTable", Object.SectionHeader); IO.mapOptional("ProgramHeaders", Object.ProgramHeaders); IO.mapOptional("Sections", Object.Chunks); IO.mapOptional("Symbols", Object.Symbols); Index: llvm/test/tools/yaml2obj/ELF/section-headers.yaml =================================================================== --- /dev/null +++ llvm/test/tools/yaml2obj/ELF/section-headers.yaml @@ -0,0 +1,186 @@ +## Check we can use "SectionHeaderTable" tag to reorder section header entries. + +## This is a general test that has sections with unique prefixes, a fill and a +## section without the unique prefix. The section header table describes sections +## in the same order they are listed in the YAML. +# RUN: yaml2obj %s --docnum=1 -o %t1 -DSEC1=".section [1]" -DSEC2=".section [2]" -DSEC3=".section.foo" +# RUN: llvm-readelf --section-headers %t1 | FileCheck %s --check-prefix=NO-OP + +# NO-OP: Section Headers: +# NO-OP-NEXT: [Nr] Name Type Address Off Size ES Flg Lk Inf Al +# NO-OP-NEXT: [ 0] NULL 0000000000000000 000000 000000 00 0 0 0 +# NO-OP-NEXT: [ 1] .section PROGBITS 0000000000000000 000040 000010 00 0 0 0 +# NO-OP-NEXT: [ 2] .section PROGBITS 0000000000000000 000050 000020 00 0 0 0 +# NO-OP-NEXT: [ 3] .section.foo PROGBITS 0000000000000000 0000a0 000040 00 0 0 0 +# NO-OP-NEXT: [ 4] .strtab STRTAB 0000000000000000 0000e0 000001 00 0 0 1 +# NO-OP-NEXT: [ 5] .shstrtab STRTAB 0000000000000000 0000e1 000029 00 0 0 1 + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 +Sections: + - Name: .section [1] + Type: SHT_PROGBITS + Size: 0x10 + - Name: .section [2] + Type: SHT_PROGBITS + Size: 0x20 + - Type: Fill + Name: .filler + Size: 0x30 + Pattern: "" + - Name: .section.foo + Type: SHT_PROGBITS + Size: 0x40 +SectionHeaderTable: + Sections: + - Name: [[SEC1]] + - Name: [[SEC2]] + - Name: [[SEC3]] + - Name: .strtab + - Name: .shstrtab + +## Show we are able to reorder sections. +# RUN: yaml2obj %s -o %t2 -DSEC3=".section [1]" -DSEC2=".section [2]" -DSEC1=".section.foo" +# RUN: llvm-readelf --section-headers %t2 | FileCheck %s --check-prefix=REORDERED + +# REORDERED: Section Headers: +# REORDERED-NEXT: [Nr] Name Type Address Off Size ES Flg Lk Inf Al +# REORDERED-NEXT: [ 0] NULL 0000000000000000 000000 000000 00 0 0 0 +# REORDERED-NEXT: [ 1] .section.foo PROGBITS 0000000000000000 0000a0 000040 00 0 0 0 +# REORDERED-NEXT: [ 2] .section PROGBITS 0000000000000000 000050 000020 00 0 0 0 +# REORDERED-NEXT: [ 3] .section PROGBITS 0000000000000000 000040 000010 00 0 0 0 +# REORDERED-NEXT: [ 4] .strtab STRTAB 0000000000000000 0000e0 000001 00 0 0 1 +# REORDERED-NEXT: [ 5] .shstrtab STRTAB 0000000000000000 0000e1 000029 00 0 0 1 + +## Show we report proper errors when the section header description: +## a) contains a repeated section name. +## b) does not list any of existent section(s). +## c) contains a undefined section. +# RUN: not yaml2obj %s -o /dev/null -DSEC1=".section.foo" -DSEC2="unknown" -DSEC3=".section.foo" 2>&1 \ +# RUN: | FileCheck %s --check-prefix=ERR1 +# d) contains a repeated implicit section name. +# e) contains a fill name. +# RUN: not yaml2obj %s -o /dev/null -DSEC1=".strtab" -DSEC2=".shstrtab" -DSEC3=".filler" 2>&1 \ +# RUN: | FileCheck %s --check-prefix=ERR2 + +# ERR1: error: repeated section name: '.section.foo' in the section header description +# ERR1-NEXT: error: section header must list the '.section [1]' section +# ERR1-NEXT: error: section header must list the '.section [2]' section +# ERR1-NEXT: error: section header contains undefined section 'unknown' + +# ERR2: error: repeated section name: '.strtab' in the section header description +# ERR2-NEXT: error: repeated section name: '.shstrtab' in the section header description +# ERR2-NEXT: error: section header must list the '.section [1]' section +# ERR2-NEXT: error: section header must list the '.section [2]' section +# ERR2-NEXT: error: section header must list the '.section.foo' section +# ERR2-NEXT: error: section header contains undefined section '.filler' + +## Test that we are able to specify an empty sections list for +## the "SectionHeaderTable" tag to produce no section header. +# RUN: yaml2obj %s --docnum=2 -o %t3 +# RUN: llvm-readelf --file-headers %t3 | FileCheck %s --check-prefix=NO-HEADERS + +# NO-HEADERS: Start of section headers: 0 (bytes into file) +# NO-HEADERS: Size of section headers: 0 (bytes) +# NO-HEADERS: Number of section headers: 0 +# NO-HEADERS: Section header string table index: 0 + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 +Sections: + - Name: .foo + Type: SHT_PROGBITS +SectionHeaderTable: + Sections: [] + +## Test that we are still able to override e_shentsize, e_shoff, +## e_shnum and e_shstrndx fields even when do not produce the section header. +# RUN: yaml2obj %s --docnum=3 -o %t4 +# RUN: llvm-readelf --file-headers %t4 | FileCheck %s --check-prefix=NO-HEADERS-OVERRIDE + +# NO-HEADERS-OVERRIDE: Start of section headers: 2 (bytes into file) +# NO-HEADERS-OVERRIDE: Size of section headers: 64 (bytes) +# NO-HEADERS-OVERRIDE: Number of section headers: 3 +# NO-HEADERS-OVERRIDE: Section header string table index: 4 + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 + SHEntSize: 64 + SHOff: 0x2 + SHNum: 0x3 + SHStrNdx: 0x4 +Sections: + - Name: .foo + Type: SHT_PROGBITS +SectionHeaderTable: + Sections: [] + +## Check that section indices are updated properly in other places when we +## reorder sections in the section header table. +# RUN: yaml2obj %s --docnum=4 -o %t5 -DSEC1=".foo" -DSEC2=".bar" +# RUN: llvm-readelf --section-headers --symbols %t5 | FileCheck %s --check-prefix=INDICES-A +# RUN: yaml2obj %s --docnum=4 -o %t6 -DSEC2=".foo" -DSEC1=".bar" +# RUN: llvm-readelf --section-headers --symbols %t6 | FileCheck %s --check-prefix=INDICES-B + +# INDICES-A: [Nr] Name Type Address Off Size ES Flg Lk +# INDICES-A: [ 1] .foo PROGBITS 0000000000000000 000040 000000 00 0 +# INDICES-A-NEXT: [ 2] .bar PROGBITS 0000000000000000 000040 000000 00 0 +# INDICES-A-NEXT: [ 3] .another.1 PROGBITS 0000000000000000 000040 000000 00 1 +# INDICES-A-NEXT: [ 4] .another.2 PROGBITS 0000000000000000 000040 000000 00 2 + +# INDICES-A: Num: Value Size Type Bind Vis Ndx Name +# INDICES-A: 1: 0000000000000000 0 NOTYPE LOCAL DEFAULT 1 foo +# INDICES-A-NEXT: 2: 0000000000000000 0 NOTYPE LOCAL DEFAULT 2 bar + +# INDICES-B: [ 1] .bar PROGBITS 0000000000000000 000040 000000 00 0 +# INDICES-B-NEXT: [ 2] .foo PROGBITS 0000000000000000 000040 000000 00 0 +# INDICES-B-NEXT: [ 3] .another.1 PROGBITS 0000000000000000 000040 000000 00 2 +# INDICES-B-NEXT: [ 4] .another.2 PROGBITS 0000000000000000 000040 000000 00 1 + +# INDICES-B: Num: Value Size Type Bind Vis Ndx Name +# INDICES-B: 1: 0000000000000000 0 NOTYPE LOCAL DEFAULT 2 foo +# INDICES-B-NEXT: 2: 0000000000000000 0 NOTYPE LOCAL DEFAULT 1 bar + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 +Sections: + - Name: .foo + Type: SHT_PROGBITS + - Name: .bar + Type: SHT_PROGBITS + - Name: .another.1 + Link: .foo + Type: SHT_PROGBITS + - Name: .another.2 + Link: .bar + Type: SHT_PROGBITS +SectionHeaderTable: + Sections: + - Name: [[SEC1]] + - Name: [[SEC2]] + - Name: .another.1 + - Name: .another.2 + - Name: .symtab + - Name: .strtab + - Name: .shstrtab +Symbols: + - Name: foo + Section: .foo + - Name: bar + Section: .bar