Index: llvm/lib/ObjectYAML/ELFEmitter.cpp =================================================================== --- llvm/lib/ObjectYAML/ELFEmitter.cpp +++ llvm/lib/ObjectYAML/ELFEmitter.cpp @@ -753,38 +753,55 @@ for (auto &YamlPhdr : Doc.ProgramHeaders) { Elf_Phdr &PHeader = PHeaders[PhdrIdx++]; std::vector Fragments = getPhdrFragments(YamlPhdr, SHeaders); - - if (YamlPhdr.Offset) { + if (!std::is_sorted(Fragments.begin(), Fragments.end(), + [](const Fragment &A, const Fragment &B) { + return A.Offset < B.Offset; + })) + reportError("sections in the program header with index " + + Twine(PhdrIdx) + " are not sorted by the file offset"); + + if (YamlPhdr.Offset) PHeader.p_offset = *YamlPhdr.Offset; - } else { - if (YamlPhdr.Sections.size()) - PHeader.p_offset = UINT32_MAX; - else - PHeader.p_offset = 0; + else if (!Fragments.empty()) + PHeader.p_offset = Fragments.front().Offset; + else + PHeader.p_offset = 0; - // Find the minimum offset for the program header. - for (const Fragment &F : Fragments) - PHeader.p_offset = std::min((uint64_t)PHeader.p_offset, F.Offset); + // Set the file size if not set explicitly. + if (YamlPhdr.FileSize) { + PHeader.p_filesz = *YamlPhdr.FileSize; + } else if (Fragments.empty()) { + PHeader.p_filesz = 0; + } else { + uint64_t FileSize = Fragments.back().Offset - PHeader.p_offset; + if (Fragments.back().Type != llvm::ELF::SHT_NOBITS) + FileSize += Fragments.back().Size; + PHeader.p_filesz = FileSize; } - // Find the maximum offset of the end of a section in order to set p_filesz - // and p_memsz. When setting p_filesz, trailing SHT_NOBITS sections are not - // counted. - uint64_t FileOffset = PHeader.p_offset, MemOffset = PHeader.p_offset; - for (const Fragment &F : Fragments) { - uint64_t End = F.Offset + F.Size; - MemOffset = std::max(MemOffset, End); - - if (F.Type != llvm::ELF::SHT_NOBITS) - FileOffset = std::max(FileOffset, End); + // Set the memory size if not set explicitly. + if (YamlPhdr.MemSize) { + PHeader.p_memsz = *YamlPhdr.MemSize; + } else if (Fragments.empty()) { + PHeader.p_memsz = 0; + } else { + uint64_t MemSize = Fragments.front().Offset - PHeader.p_offset; + for (size_t I = 0, E = Fragments.size(); I != E; ++I) { + const Fragment &Cur = Fragments[I]; + const Fragment *Next = + (I + 1 < Fragments.size()) ? &Fragments[I + 1] : nullptr; + + // The distance between the current and the next section can + // be larger than the size of the currect section when the + // alignment gap present. + if (Next) + MemSize += std::max(Next->Offset - Cur.Offset, Cur.Size); + else + MemSize += Cur.Size; + } + PHeader.p_memsz = MemSize; } - // Set the file size and the memory size if not set explicitly. - PHeader.p_filesz = YamlPhdr.FileSize ? uint64_t(*YamlPhdr.FileSize) - : FileOffset - PHeader.p_offset; - PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize) - : MemOffset - PHeader.p_offset; - if (YamlPhdr.Align) { PHeader.p_align = *YamlPhdr.Align; } else { Index: llvm/test/Object/invalid.test =================================================================== --- llvm/test/Object/invalid.test +++ llvm/test/Object/invalid.test @@ -485,17 +485,11 @@ Data: ELFDATA2LSB Type: ET_EXEC Machine: EM_X86_64 -Sections: - - Name: .dynamic - Type: SHT_DYNAMIC - Entries: - - Tag: DT_NULL - Value: 0 ProgramHeaders: - - Type: PT_DYNAMIC - Offset: 0xffff0000 - Sections: - - Section: .dynamic + - Type: PT_DYNAMIC + Offset: 0xffff0000 + FileSize: 0x10 + Sections: [] ## PT_DYNAMIC's p_filesz field is so large that p_offset + p_filesz is larger ## than the object size. Check llvm-readobj reports it. Index: llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml =================================================================== --- llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml +++ llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml @@ -395,8 +395,6 @@ - Section: .note.ABI-tag - Section: .note.gnu.build-id - Section: .gnu.hash - - Section: .dynsym - - Section: .dynstr - Section: .gnu.version - Section: .gnu.version_r - Section: .rela.dyn @@ -409,6 +407,8 @@ - Section: .rodata - Section: .eh_frame_hdr - Section: .eh_frame + - Section: .dynsym + - Section: .dynstr Symbols: - Name: .interp Type: STT_SECTION Index: llvm/test/tools/llvm-readobj/ELF/demangle.test =================================================================== --- llvm/test/tools/llvm-readobj/ELF/demangle.test +++ llvm/test/tools/llvm-readobj/ELF/demangle.test @@ -213,8 +213,8 @@ Flags: [ PF_R, PF_X ] VAddr: 0x0 Sections: - - Section: .dynsym - Section: .dynstr + - Section: .dynsym - Section: .rela.dyn - Section: .dynamic - Section: .text.foo Index: llvm/test/tools/llvm-readobj/ELF/gnu-notes.test =================================================================== --- llvm/test/tools/llvm-readobj/ELF/gnu-notes.test +++ llvm/test/tools/llvm-readobj/ELF/gnu-notes.test @@ -165,15 +165,10 @@ Data: ELFDATA2LSB Type: ET_CORE Machine: EM_X86_64 -Sections: - - Name: .note - Type: SHT_NOTE - Notes: [] ProgramHeaders: - - Type: PT_NOTE - Offset: 0xffff0000 - Sections: - - Section: .note + - Type: PT_NOTE + Offset: 0xffff0000 + Sections: [] ## Test tools report an error if a note program header has an invalid size that ## goes past the end of file. Index: llvm/test/tools/llvm-readobj/ELF/hash-symbols.test =================================================================== --- llvm/test/tools/llvm-readobj/ELF/hash-symbols.test +++ llvm/test/tools/llvm-readobj/ELF/hash-symbols.test @@ -298,8 +298,8 @@ Flags: [ PF_R, PF_X ] VAddr: 0x0 Sections: - - Section: .dynsym - Section: .dynstr + - Section: .dynsym - Section: .dynamic - Section: .text.foo - Type: PT_DYNAMIC Index: llvm/test/tools/llvm-readobj/ELF/reloc-negative-addend-no-sym.test =================================================================== --- llvm/test/tools/llvm-readobj/ELF/reloc-negative-addend-no-sym.test +++ llvm/test/tools/llvm-readobj/ELF/reloc-negative-addend-no-sym.test @@ -65,8 +65,8 @@ - Type: PT_LOAD VAddr: 0x1000 Sections: - - Section: .rela.dyn - Section: .dynamic + - Section: .rela.dyn - Type: PT_DYNAMIC VAddr: 0x1000 Sections: Index: llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test =================================================================== --- llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test +++ llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test @@ -101,8 +101,8 @@ - Type: PT_LOAD VAddr: 0x1000 Sections: - - Section: .rela.dyn - Section: .dynamic + - Section: .rela.dyn - Type: PT_DYNAMIC VAddr: 0x1000 Sections: Index: llvm/test/tools/obj2yaml/program-headers.yaml =================================================================== --- llvm/test/tools/obj2yaml/program-headers.yaml +++ llvm/test/tools/obj2yaml/program-headers.yaml @@ -414,3 +414,60 @@ Type: SHT_PROGBITS Flags: [ SHF_ALLOC ] Size: 0x1 + +## Document we require sections in a program header +## declaration to be sorted by the file offset. +# RUN: not yaml2obj --docnum=5 %s -o %t5 2>&1 | \ +# RUN: FileCheck %s --check-prefix=UNSORTED --implicit-check-not="error:" + +# UNSORTED: error: sections in the program header with index 1 are not sorted by the file offset +# UNSORTED-NEXT: error: sections in the program header with index 3 are not sorted by the file offset + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_DYN + Machine: EM_X86_64 +ProgramHeaders: +## Case 1: the .bar section is placed after the .foo section in the file. +## Check we report an error about the violation of the order. + - Type: PT_LOAD + Flags: [ PF_R ] + Sections: + - Section: .bar + - Section: .foo + VAddr: 0x1000 +## Case 2: there is nothing wrong with this segment. We have it to show that +## we report correct program header indices in error messages. + - Type: PT_LOAD + Flags: [ PF_R ] + Sections: + - Section: .foo + - Section: .bar + VAddr: 0x1000 +## Case 3: the .bar section is placed before the .zed section in the file, +## but the the sh_offset of .zed is less than the sh_offset of +## the .bar section because of the "ShOffset" property. +## Document we report an error for such case. + - Type: PT_LOAD + Flags: [ PF_R ] + Sections: + - Section: .bar + - Section: .zed + VAddr: 0x1001 +Sections: + - Name: .foo + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC ] + Size: 0x1 + Address: 0x1000 + - Name: .bar + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC ] + Size: 0x1 + - Name: .zed + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC ] + Size: 0x1 + ShOffset: 0x0 Index: llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml =================================================================== --- llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml +++ llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml @@ -1,39 +1,144 @@ -# RUN: yaml2obj %s -o %t -# RUN: llvm-readobj -l %t | FileCheck %s +## Here we test that yaml2obj is able to handle SHT_NOBITS sections properly. -!ELF +## Set the file offset of the first segment to 0x0 +# RUN: yaml2obj %s --docnum=1 -DOFFSET=0x0 -o %t1 +# RUN: llvm-readelf --sections --segments %t1 | FileCheck %s --check-prefixes=COMMON,NOOFFSET + +## Set file offsets of segments to the offset of the first section to show +## that with a non-zero offset we still calculate memory and file sizes properly. +# RUN: yaml2obj %s --docnum=1 -DOFFSET=0x158 -o %t2 +# RUN: llvm-readelf --sections --segments %t2 | FileCheck %s --check-prefixes=COMMON,OFFSET + +## Show the layout produced. +# COMMON: Section Headers: +# COMMON-NEXT: [Nr] Name Type Address Off Size ES Flg Lk Inf Al +# COMMON-NEXT: [ 0] NULL 0000000000000000 000000 000000 00 0 0 0 +# COMMON-NEXT: [ 1] .nobits1 NOBITS 0000000200000000 000158 000010 00 WA 0 0 0 +# COMMON-NEXT: [ 2] .progbits1 PROGBITS 0000000200000010 000158 000001 00 WA 0 0 0 +# COMMON-NEXT: [ 3] .progbits2 PROGBITS 0000000200000020 000160 000010 00 WA 0 0 16 +# COMMON-NEXT: [ 4] .nobits2 NOBITS 0000000200000030 000170 000020 00 WA 0 0 0 +## The .filler chuck (size = 0x90) is placed here. +# COMMON-NEXT: [ 5] .nobits3 NOBITS 00000002000000e0 000200 0001d0 00 WA 0 0 0 +# COMMON-NEXT: [ 6] .nobits4 NOBITS 00000002000002b0 000200 000100 00 WA 0 0 0 +# COMMON-NEXT: [ 7] .strtab STRTAB 0000000000000000 000200 000001 00 0 0 1 + +# COMMON: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align +## This segment includes sections from 1 to 6. +# NOOFFSET-NEXT: LOAD 0x000000 0x0000000200000000 0x0000000200000000 0x000200 0x000500 RW 0x10 +# OFFSET-NEXT: LOAD 0x000158 0x0000000200000000 0x0000000200000000 0x0000a8 0x0003a8 RW 0x10 +## This segment includes sections from 1 to 5. +# NOOFFSET-NEXT: LOAD 0x000000 0x0000000200000000 0x0000000200000000 0x000200 0x000400 RW 0x10 +# OFFSET-NEXT: LOAD 0x000158 0x0000000200000000 0x0000000200000000 0x0000a8 0x0002a8 RW 0x10 +## This segment includes sections from 1 to 4 + .filler chunk. +# NOOFFSET-NEXT: LOAD 0x000000 0x0000000200000000 0x0000000200000000 0x000200 0x000230 RW 0x10 +# OFFSET-NEXT: LOAD 0x000158 0x0000000200000000 0x0000000200000000 0x0000a8 0x0000d8 RW 0x10 +## This segment includes first two sections. +# NOOFFSET-NEXT: LOAD 0x000000 0x0000000200000000 0x0000000200000000 0x000159 0x000169 RW 0x1 +# OFFSET-NEXT: LOAD 0x000158 0x0000000200000000 0x0000000200000000 0x000001 0x000011 RW 0x1 +## This segment includes the first section only. +# NOOFFSET-NEXT: LOAD 0x000000 0x0000000200000000 0x0000000200000000 0x000158 0x000168 RW 0x1 +# OFFSET-NEXT: LOAD 0x000158 0x0000000200000000 0x0000000200000000 0x000000 0x000010 RW 0x1 + +--- !ELF FileHeader: - Class: ELFCLASS64 - Data: ELFDATA2LSB - Type: ET_EXEC - Machine: EM_X86_64 -Sections: - - Name: .data - Type: SHT_PROGBITS - Flags: [ SHF_ALLOC ] - Content: "00000000" - - Name: .after - Type: SHT_NOBITS - Flags: [ SHF_ALLOC ] - Size: 64 + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_EXEC + Machine: EM_X86_64 ProgramHeaders: - - Type: PT_LOAD - Flags: [ PF_R ] +## The segment that has all the sections included and has +## two SHT_PROGBITS sections at the end. + - Type: PT_LOAD + Flags: [ PF_W, PF_R ] Sections: - - Section: .data - - Section: .after - -#CHECK: ProgramHeaders [ -#CHECK-NEXT: ProgramHeader { -#CHECK-NEXT: Type: PT_LOAD -#CHECK-NEXT: Offset: -#CHECK-NEXT: VirtualAddress: -#CHECK-NEXT: PhysicalAddress: -#CHECK-NEXT: FileSize: 4 -#CHECK-NEXT: MemSize: 68 -#CHECK-NEXT: Flags [ -#CHECK-NEXT: PF_R -#CHECK-NEXT: ] -#CHECK-NEXT: Alignment: -#CHECK-NEXT: } -#CHECK-NEXT:] + - Section: .nobits1 + - Section: .progbits1 + - Section: .progbits2 + - Section: .nobits2 + - Section: .filler + - Section: .nobits3 + - Section: .nobits4 + VAddr: 0x200000000 + Offset: [[OFFSET]] +## The segment with SHT_NOBITS sections has a single +## SHT_PROGBITS section at the end. + - Type: PT_LOAD + Flags: [ PF_W, PF_R ] + Sections: + - Section: .nobits1 + - Section: .progbits1 + - Section: .progbits2 + - Section: .nobits2 + - Section: .filler + - Section: .nobits3 + VAddr: 0x200000000 + Offset: [[OFFSET]] +## The segment with SHT_NOBITS sections has a Fill +## chunk at the end. + - Type: PT_LOAD + Flags: [ PF_W, PF_R ] + Sections: + - Section: .nobits1 + - Section: .progbits1 + - Section: .progbits2 + - Section: .nobits2 + - Section: .filler + VAddr: 0x200000000 + Offset: [[OFFSET]] +## The segment with SHT_NOBITS section has a +## SHT_PROGBITS section at the end. + - Type: PT_LOAD + Flags: [ PF_W, PF_R ] + Sections: + - Section: .nobits1 + - Section: .progbits1 + VAddr: 0x200000000 + Offset: [[OFFSET]] +## The segment has only a SHT_NOBITS section included. + - Type: PT_LOAD + Flags: [ PF_W, PF_R ] + Sections: + - Section: .nobits1 + VAddr: 0x200000000 + Offset: [[OFFSET]] +Sections: +## We have a SHT_NOBITS section at the start of the segment. + - Name: .nobits1 + Type: SHT_NOBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x10 + Address: 0x200000000 + - Name: .progbits1 +## It is followed by two SHT_PROGBITS sections. Note that the virtual +## address of the .progbits2 is aligned so that there is an alignment gap +## between .progbits1 and .progbits2 sections. + Type: SHT_PROGBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x1 + - Name: .progbits2 + Type: SHT_PROGBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x10 + AddressAlign: 0x10 +## We have a SHT_NOBITS section at the middle of the segment. + - Name: .nobits2 + Type: SHT_NOBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x20 +## We have a Fill chunk. + - Type: Fill + Name: .filler + Pattern: "CCDD" + Size: 0x90 +## We have two SHT_NOBITS section at the end of the segment. +## It is important to have at least two of them because we had a bug +## related to an incorrect computation of the memory size of a segment when +## there were multiple SHT_NOBITS sections at the end. + - Name: .nobits3 + Type: SHT_NOBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x1D0 + - Name: .nobits4 + Type: SHT_NOBITS + Flags: [ SHF_WRITE, SHF_ALLOC ] + Size: 0x100 Index: llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml =================================================================== --- llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml +++ llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml @@ -30,7 +30,7 @@ # CHECK: MemSize: 2 # CHECK: Offset: 0x2004 -# CHECK: FileSize: 4 +# CHECK: FileSize: 5 # CHECK: MemSize: 6 # CHECK: ]