This is an archive of the discontinued LLVM Phabricator instance.

Differential D90458

[yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections list.
ClosedPublic

Authored by grimar on Oct 30 2020, 6:16 AM.

Details

Reviewers
jhenderson
MaskRay
• espindola
alexander-shaposhnikov
rupprecht
Commits
rGa7a447be0fa9: [yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections…
Summary

Imagine we have a YAML declaration of few sections: foo1, <unnamed 2>, foo3, foo4.

To put them into segment we can do (1*):

Sections:
 - Section: foo1
 - Section: foo4

or we can use (2*):

Sections:
 - Section: foo1
 - Section: foo3
 - Section: foo4

or (3*) :

Sections:
 - Section: foo1
## "(index 2)" here is a name that we automatically created for a unnamed section.
 - Section: (index 2)
 - Section: foo3
 - Section: foo4

It looks really confusing that we don't have to list all of sections.

At first I've tried to make this rule stricter and report an error when there is a gap
(i.e. when a section is included into segment, but not listed explicitly).
This did not work perfect, because such approach conflicts with unnamed sections/fills (see (3*)).

This patch drops "Sections" key and introduces 2 keys instead: FirstSec and LastSec.
Both are optional.

Diff Detail

Event Timeline

grimar created this revision.Oct 30 2020, 6:16 AM
Herald added a reviewer: • espindola. · View Herald TranscriptOct 30 2020, 6:16 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: hiraditya, emaste. · View Herald Transcript
grimar requested review of this revision.Oct 30 2020, 6:16 AM
MaskRay added a comment.EditedOct 30 2020, 9:51 AM

The idea looks good. It is used by LLD to compute p_filesz/p_memsz:)

I can understand that if a segment contains many sections, it can be inconvenient to enumerate every one.

jhenderson added a comment.Nov 2 2020, 12:39 AM

As long as this approach still allows creating program headers with the exact same contents as before (i.e. it's as flexible as possible), then it makes sense to me too. Happy for you to proceed.

grimar added a comment.Nov 2 2020, 2:13 AM
In D90458#2367707, @jhenderson wrote:

As long as this approach still allows creating program headers with the exact same contents as before (i.e. it's as flexible as possible), then it makes sense to me too. Happy for you to proceed.

It indeed will be at least on the same level of flexibility.

FTR, partially I was inspired by the following possible situation. Currently we allocate a space for nobits sections in a segment when there are
fills or non-nobits sections after them:

static bool shouldAllocateFileSpace(ArrayRef<ELFYAML::ProgramHeader> Phdrs,
                                    const ELFYAML::NoBitsSection &S) {
  for (const ELFYAML::ProgramHeader &PH : Phdrs) {
    auto It = llvm::find_if(
        PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
    if (std::any_of(It, PH.Chunks.end(), [](ELFYAML::Chunk *C) {
          return (isa<ELFYAML::Fill>(C) ||
                  cast<ELFYAML::Section>(C)->Type != ELF::SHT_NOBITS);
        }))
      return true;
  }
  return false;
}

If we have a segment with sections:
<regular1>, <nobits1>, <regular2>, <nobits2>

Then we might have a segment description that specifies only <regular1> and <nobits2>:

Sections:
  - Section: <regular1>
  - Section: <nobits2>

and it will be different from the case where we explicitly specify all of sections,
because in the case above I believe we will not allocate a space for the <nobits1> section with the current code.

That is why I tried to implement a requirement about that all sections must explicitly present in the segment description at first.

With the solution that this patch suggests it should be impossible to trigger the possible bug/misbehavior I've described.

grimar updated this revision to Diff 302485.Nov 3 2020, 12:20 AM
grimar retitled this revision from [yaml2obj][WIP] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections list. to [yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections list..
grimar edited the summary of this revision. (Show Details)
  • Updated other tests. Added a few new ones.

Ready for review.

Herald added a reviewer: alexander-shaposhnikov. · View Herald TranscriptNov 3 2020, 12:20 AM
Herald added a reviewer: rupprecht. · View Herald Transcript
Herald added a subscriber: rupprecht. · View Herald Transcript
jhenderson added inline comments.Nov 3 2020, 1:36 AM
llvm/lib/ObjectYAML/ELFEmitter.cpp
502–508

The behaviour here is a little subtle (relying on the zero-value insertion of a size_t when a member doesn't exist). I wonder if it would be worth adding some comments to make it clearer?

507

This behaviour isn't immediately clear to me as being the behaviour when just FirstSec is specified. It could easily be thought that just FirstSec implies that section and all later sections. What do you think about requiring both keys if either is specified?

512

Maybe worth bailing out at this point if either First or Last are invalid, rahter than needing the if (First && Last) bits here.

llvm/lib/ObjectYAML/ELFYAML.cpp
919
llvm/test/tools/llvm-objdump/X86/elf-dynamic-relocs.test
99

Side-note: this one was previously missing .got.plt!

llvm/test/tools/obj2yaml/ELF/program-headers.yaml
347–348

This comment probably needs updating.

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml
266–271

We probably need the same test case but for the LastSec key.

llvm/test/tools/yaml2obj/ELF/program-header.yaml
121
122
136
154

Should we have a test case showing that Fills are included as well?

grimar updated this revision to Diff 303063.Nov 5 2020, 2:39 AM
grimar marked 11 inline comments as done.
grimar edited the summary of this revision. (Show Details)
  • Addressed review comments.
llvm/lib/ObjectYAML/ELFEmitter.cpp
507

It could easily be thought that just FirstSec implies that section and all later sections.

I had such concern too. Was not sure what is better. I've made both keys to be required if either is specified.

llvm/test/tools/obj2yaml/ELF/program-headers.yaml
347–348

I've updated the test itself instead.

jhenderson added inline comments.Nov 5 2020, 4:43 AM
llvm/lib/ObjectYAML/ELFEmitter.cpp
488–500
llvm/test/tools/llvm-readobj/ELF/gnu-notes.test
192
llvm/test/tools/llvm-readobj/ELF/hash-histogram.test
412
llvm/test/tools/obj2yaml/ELF/program-headers.yaml
403–405

We probably need a case where .non-alloc.2 would be the LastSec too.

llvm/tools/obj2yaml/elf2yaml.cpp
392–399

Does this loop work if section headers are not in section offset order? Or are they guaranteed to be by some sorting earlier on?

grimar marked an inline comment as done.Nov 6 2020, 1:09 AM
grimar added inline comments.
llvm/tools/obj2yaml/elf2yaml.cpp
392–399

I have no short answer, we have a specific behavior for cases where sections are not in the
section offset order currently, let me describe it.

Imagine we have 3 sections:
.foo at offset 0x100, .bar at offset 0x200 and .zed at offset 0x300.
And lets have a section header table where they are in a different order:
.zed (0x300), .foo (0x100) and .bar (0x200).

And lets have a segment [.foo, .zed]. The YAML for this case is shown below:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
Sections:
  - Name:    .foo
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x1
    Offset:  0x100
  - Name:    .bar
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x2
    Offset:  0x200
  - Name:    .zed
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x3
    Offset:  0x300
SectionHeaderTable:
  Sections:
    - Name: .zed
    - Name: .foo
    - Name: .bar
    - Name: .strtab
    - Name: .shstrtab
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_W, PF_R ]
    VAddr:    0x1000
    FirstSec: .foo
    LastSec:  .zed

after applying obj2yaml we have:

--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_EXEC
ProgramHeaders:
  - Type:            PT_LOAD
    Flags:           [ PF_W, PF_R ]
    FirstSec:        .zed
    LastSec:         .bar
    VAddr:           0x0000000000001000
Sections:
  - Name:            .zed
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000003
    Content:         '000000'
  - Name:            .foo
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Content:         '00'
  - Name:            .bar
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000001
    Content:         '0000'
...

What is noticable:

  1. We lost the information about the section header order. I.e. now the order is not .foo .bar. zed, but .zed .foo .bar. Because we dump sections by section header table order only and don't try to preserve section offsets.
  2. FirstSec/LastSec were changed, but they match the YAML produced.
jhenderson added inline comments.Nov 6 2020, 1:32 AM
llvm/tools/obj2yaml/elf2yaml.cpp
392–399

My opinion is that we don't need to preserve in the YAML the section header table order, as long as the semantic meaning is identical. Section offset order likely needs maintaining if the sections are inside segments, or any hard-coded addresses will end up breaking, right? It sounds like that might be an issue already though?

grimar updated this revision to Diff 303371.Nov 6 2020, 1:43 AM
grimar marked 5 inline comments as done.
  • Addressed review comments.
llvm/tools/obj2yaml/elf2yaml.cpp
392–399

Yeah, I think so.

I guess we want do dump sections as we do now, but then sort them by file offsets (i.e. sort Chunks) and also emit the Offset field (perhaps not always, but when the aligned [previous offset + size of previous section] value doesn't match the offset of a section dumped).

Though I'd like to experiment with this are probably at first to see if there is something not obvious that I may be missing.

jhenderson accepted this revision.Nov 6 2020, 2:02 AM

I think this patch looks good. The section offset ordering thing is probably an independent change.

This revision is now accepted and ready to land.Nov 6 2020, 2:02 AM
jhenderson mentioned this in D90897: [llvm-objcopy] --only-keep-debug: place zero-size segment according to its parent segment.Nov 6 2020, 2:18 AM
MaskRay accepted this revision.Nov 6 2020, 8:43 AM
Closed by commit rGa7a447be0fa9: [yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections… (authored by grimar). · Explain WhyNov 9 2020, 2:15 AM
This revision was automatically updated to reflect the committed changes.
grimar added a commit: rGa7a447be0fa9: [yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections….
grimar mentioned this in rG62e3b2ec1d8e: [lldb][test] - Update test cases after yaml2obj change..Nov 9 2020, 2:54 AM
grimar mentioned this in D91249: [obj2yaml] - Teach tool to emit the "SectionHeaderTable" key and sort sections by file offset..Nov 12 2020, 12:21 AM

Revision Contents

PathSize
llvm/
include/
llvm/
ObjectYAML/
15 lines
lib/
ObjectYAML/
46 lines
17 lines
test/
DebugInfo/
8 lines
8 lines
Object/
12 lines
22 lines
tools/
llvm-elfabi/
17 lines
23 lines
23 lines
23 lines
16 lines
14 lines
23 lines
23 lines
23 lines
23 lines
23 lines
llvm-gsymutil/
X86/
22 lines
llvm-objcopy/
ELF/
Inputs/
12 lines
16 lines
24 lines
16 lines
8 lines
8 lines
11 lines
24 lines
31 lines
12 lines
12 lines
12 lines
20 lines
8 lines
24 lines
24 lines
6 lines
8 lines
21 lines
26 lines
8 lines
35 lines
8 lines
26 lines
36 lines
21 lines
4 lines
366 lines
25 lines
5 lines
20 lines
20 lines
10 lines
6 lines
6 lines
12 lines
9 lines
42 lines
22 lines
22 lines
22 lines
llvm-objdump/
ELF/
60 lines
34 lines
X86/
8 lines
12 lines
25 lines
21 lines
31 lines
9 lines
llvm-readobj/
ELF/
27 lines
59 lines
6 lines
24 lines
64 lines
41 lines
16 lines
98 lines
8 lines
51 lines
15 lines
10 lines
24 lines
60 lines
17 lines
12 lines
22 lines
45 lines
55 lines
108 lines
34 lines
5 lines
4 lines
14 lines
54 lines
24 lines
6 lines
6 lines
221 lines
17 lines
17 lines
19 lines
llvm-xray/
ARM/
35 lines
obj2yaml/
ELF/
529 lines
yaml2obj/
ELF/
27 lines
22 lines
12 lines
31 lines
12 lines
28 lines
53 lines
113 lines
tools/
obj2yaml/
7 lines

Diff 303371

llvm/include/llvm/ObjectYAML/ELFYAML.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
}; };
struct SectionHeaderTable { struct SectionHeaderTable {
Optional<std::vector<SectionHeader>> Sections; Optional<std::vector<SectionHeader>> Sections;
Optional<std::vector<SectionHeader>> Excluded; Optional<std::vector<SectionHeader>> Excluded;
Optional<bool> NoHeaders; Optional<bool> NoHeaders;
}; };
struct SectionName {
StringRef Section;
};
struct Symbol { struct Symbol {
StringRef Name; StringRef Name;
ELF_STT Type; ELF_STT Type;
StringRef Section; StringRef Section;
Optional<ELF_SHN> Index; Optional<ELF_SHN> Index;
ELF_STB Binding; ELF_STB Binding;
llvm::yaml::Hex64 Value; llvm::yaml::Hex64 Value;
llvm::yaml::Hex64 Size; llvm::yaml::Hex64 Size;
▲ Show 20 Lines • Show All 482 Lines • ▼ Show 20 Linesstruct ProgramHeader {
ELF_PT Type; ELF_PT Type;
ELF_PF Flags; ELF_PF Flags;
llvm::yaml::Hex64 VAddr; llvm::yaml::Hex64 VAddr;
llvm::yaml::Hex64 PAddr; llvm::yaml::Hex64 PAddr;
Optional<llvm::yaml::Hex64> Align; Optional<llvm::yaml::Hex64> Align;
Optional<llvm::yaml::Hex64> FileSize; Optional<llvm::yaml::Hex64> FileSize;
Optional<llvm::yaml::Hex64> MemSize; Optional<llvm::yaml::Hex64> MemSize;
Optional<llvm::yaml::Hex64> Offset; Optional<llvm::yaml::Hex64> Offset;
Optional<StringRef> FirstSec;
Optional<StringRef> LastSec;
std::vector<SectionName> Sections; // This vector contains all chunks from [FirstSec, LastSec].
// This vector is parallel to Sections and contains corresponding chunks.
std::vector<Chunk *> Chunks; std::vector<Chunk *> Chunks;
}; };
struct Object { struct Object {
FileHeader Header; FileHeader Header;
Optional<SectionHeaderTable> SectionHeaders; Optional<SectionHeaderTable> SectionHeaders;
std::vector<ProgramHeader> ProgramHeaders; std::vector<ProgramHeader> ProgramHeaders;
Show All 32 Lines
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>) LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)
namespace llvm { namespace llvm {
namespace yaml { namespace yaml {
template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> { template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx, static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
raw_ostream &Out); raw_ostream &Out);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
}; };
template <> struct MappingTraits<ELFYAML::SectionHeader> { template <> struct MappingTraits<ELFYAML::SectionHeader> {
static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr); static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
}; };
template <> struct MappingTraits<ELFYAML::ProgramHeader> { template <> struct MappingTraits<ELFYAML::ProgramHeader> {
static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr); static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
}; };
template <> template <>
struct MappingTraits<ELFYAML::Symbol> { struct MappingTraits<ELFYAML::Symbol> {
static void mapping(IO &IO, ELFYAML::Symbol &Symbol); static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
static std::string validate(IO &IO, ELFYAML::Symbol &Symbol); static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
}; };
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
struct MappingTraits<ELFYAML::Object> { struct MappingTraits<ELFYAML::Object> {
static void mapping(IO &IO, ELFYAML::Object &Object); static void mapping(IO &IO, ELFYAML::Object &Object);
}; };
template <> struct MappingTraits<ELFYAML::SectionOrType> { template <> struct MappingTraits<ELFYAML::SectionOrType> {
static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType); static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
}; };
template <> struct MappingTraits<ELFYAML::SectionName> {
static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
};
} // end namespace yaml } // end namespace yaml
} // end namespace llvm } // end namespace llvm
#endif // LLVM_OBJECTYAML_ELFYAML_H #endif // LLVM_OBJECTYAML_ELFYAML_H

llvm/lib/ObjectYAML/ELFEmitter.cpp

Show First 20 Lines • Show All 458 Lines • ▼ Show 20 Lines else
Header.e_shstrndx = 0; Header.e_shstrndx = 0;
OS.write((const char *)&Header, sizeof(Header)); OS.write((const char *)&Header, sizeof(Header));
} }
template <class ELFT> template <class ELFT>
void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) { void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
DenseMap<StringRef, ELFYAML::Fill *> NameToFill; DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) DenseMap<StringRef, size_t> NameToIndex;
if (auto S = dyn_cast<ELFYAML::Fill>(D.get())) for (size_t I = 0, E = Doc.Chunks.size(); I != E; ++I) {
if (auto S = dyn_cast<ELFYAML::Fill>(Doc.Chunks[I].get()))
NameToFill[S->Name] = S; NameToFill[S->Name] = S;
NameToIndex[Doc.Chunks[I]->Name] = I + 1;
}
std::vector<ELFYAML::Section *> Sections = Doc.getSections(); std::vector<ELFYAML::Section *> Sections = Doc.getSections();
for (ELFYAML::ProgramHeader &YamlPhdr : Doc.ProgramHeaders) { for (size_t I = 0, E = Doc.ProgramHeaders.size(); I != E; ++I) {
ELFYAML::ProgramHeader &YamlPhdr = Doc.ProgramHeaders[I];
Elf_Phdr Phdr; Elf_Phdr Phdr;
zero(Phdr); zero(Phdr);
Phdr.p_type = YamlPhdr.Type; Phdr.p_type = YamlPhdr.Type;
Phdr.p_flags = YamlPhdr.Flags; Phdr.p_flags = YamlPhdr.Flags;
Phdr.p_vaddr = YamlPhdr.VAddr; Phdr.p_vaddr = YamlPhdr.VAddr;
Phdr.p_paddr = YamlPhdr.PAddr; Phdr.p_paddr = YamlPhdr.PAddr;
PHeaders.push_back(Phdr); PHeaders.push_back(Phdr);
// Map Sections list to corresponding chunks. if (!YamlPhdr.FirstSec && !YamlPhdr.LastSec)
for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
if (ELFYAML::Fill *Fill = NameToFill.lookup(SecName.Section)) {
YamlPhdr.Chunks.push_back(Fill);
continue; continue;
}
unsigned Index; // Get the index of the section, or 0 in the case when the section doesn't exist.
if (SN2I.lookup(SecName.Section, Index)) { size_t First = NameToIndex[*YamlPhdr.FirstSec];
YamlPhdr.Chunks.push_back(Sections[Index]); if (!First)
reportError("unknown section or fill referenced: '" + *YamlPhdr.FirstSec +
"' by the 'FirstSec' key of the program header with index " +
Twine(I));
size_t Last = NameToIndex[*YamlPhdr.LastSec];
if (!Last)
reportError("unknown section or fill referenced: '" + *YamlPhdr.LastSec +
"' by the 'LastSec' key of the program header with index " +
Twine(I));
if (!First || !Last)
continue; continue;
jhendersonUnsubmitted
Done
ReplyInline Actions
continue;
- // Get the index of section, or 0 in case when the section doesn't exist.
+ // Get the index of the section, or 0 in the case when the section doesn't exist.
size_t First = NameToIndex[*YamlPhdr.FirstSec];
jhenderson:
}
reportError("unknown section or fill referenced: '" + SecName.Section + if (First > Last)
"' by program header"); reportError("program header with index " + Twine(I) +
} ": the section index of " + *YamlPhdr.FirstSec +
" is greater than the index of " + *YamlPhdr.LastSec);
for (size_t I = First; I <= Last; ++I)
jhendersonUnsubmitted
Done
ReplyInline Actions

This behaviour isn't immediately clear to me as being the behaviour when just FirstSec is specified. It could easily be thought that just FirstSec implies that section and all later sections. What do you think about requiring both keys if either is specified?

jhenderson: This behaviour isn't immediately clear to me as being the behaviour when just `FirstSec` is…
grimarAuthorUnsubmitted
Done
ReplyInline Actions

It could easily be thought that just FirstSec implies that section and all later sections.

I had such concern too. Was not sure what is better. I've made both keys to be required if either is specified.

grimar: > It could easily be thought that just FirstSec implies that section and all later sections. I…
YamlPhdr.Chunks.push_back(Doc.Chunks[I - 1].get());
jhendersonUnsubmitted
Done
ReplyInline Actions

The behaviour here is a little subtle (relying on the zero-value insertion of a size_t when a member doesn't exist). I wonder if it would be worth adding some comments to make it clearer?

jhenderson: The behaviour here is a little subtle (relying on the zero-value insertion of a size_t when a…
} }
} }
template <class ELFT> template <class ELFT>
jhendersonUnsubmitted
Done
ReplyInline Actions

Maybe worth bailing out at this point if either First or Last are invalid, rahter than needing the if (First && Last) bits here.

jhenderson: Maybe worth bailing out at this point if either `First` or `Last` are invalid, rahter than…
unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec, unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
StringRef LocSym) { StringRef LocSym) {
assert(LocSec.empty() || LocSym.empty()); assert(LocSec.empty() || LocSym.empty());
unsigned Index; unsigned Index;
if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) { if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) {
if (!LocSym.empty()) if (!LocSym.empty())
reportError("unknown section referenced: '" + S + "' by YAML symbol '" + reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
▲ Show 20 Lines • Show All 1,430 Lines • Show Last 20 Lines

llvm/lib/ObjectYAML/ELFYAML.cpp

Show First 20 Lines • Show All 897 Lines • ▼ Show 20 Linesvoid MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
IO.mapOptional("EShNum", FileHdr.EShNum); IO.mapOptional("EShNum", FileHdr.EShNum);
IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx); IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
} }
void MappingTraits<ELFYAML::ProgramHeader>::mapping( void MappingTraits<ELFYAML::ProgramHeader>::mapping(
IO &IO, ELFYAML::ProgramHeader &Phdr) { IO &IO, ELFYAML::ProgramHeader &Phdr) {
IO.mapRequired("Type", Phdr.Type); IO.mapRequired("Type", Phdr.Type);
IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0)); IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
IO.mapOptional("Sections", Phdr.Sections); IO.mapOptional("FirstSec", Phdr.FirstSec);
IO.mapOptional("LastSec", Phdr.LastSec);
IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0)); IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr); IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
IO.mapOptional("Align", Phdr.Align); IO.mapOptional("Align", Phdr.Align);
IO.mapOptional("FileSize", Phdr.FileSize); IO.mapOptional("FileSize", Phdr.FileSize);
IO.mapOptional("MemSize", Phdr.MemSize); IO.mapOptional("MemSize", Phdr.MemSize);
IO.mapOptional("Offset", Phdr.Offset); IO.mapOptional("Offset", Phdr.Offset);
} }
std::string MappingTraits<ELFYAML::ProgramHeader>::validate(
IO &IO, ELFYAML::ProgramHeader &FileHdr) {
if (!FileHdr.FirstSec && FileHdr.LastSec)
return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
jhendersonUnsubmitted
Done
ReplyInline Actions
if (!FileHdr.FirstSec && FileHdr.LastSec)
- return "the \"LastSec\" can't be used without the \"FirstSec\" key";
+ return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
return "";
jhenderson:
if (FileHdr.FirstSec && !FileHdr.LastSec)
return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
return "";
}
LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece) LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
template <> struct ScalarTraits<StOtherPiece> { template <> struct ScalarTraits<StOtherPiece> {
static void output(const StOtherPiece &Val, void *, raw_ostream &Out) { static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
Out << Val; Out << Val;
} }
static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) { static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
Val = Scalar; Val = Scalar;
▲ Show 20 Lines • Show All 325 Lines • ▼ Show 20 Linesstatic void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
IO.mapOptional("Entries", Section.Entries); IO.mapOptional("Entries", Section.Entries);
} }
void MappingTraits<ELFYAML::SectionOrType>::mapping( void MappingTraits<ELFYAML::SectionOrType>::mapping(
IO &IO, ELFYAML::SectionOrType &sectionOrType) { IO &IO, ELFYAML::SectionOrType &sectionOrType) {
IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType); IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
} }
void MappingTraits<ELFYAML::SectionName>::mapping(
IO &IO, ELFYAML::SectionName &sectionName) {
IO.mapRequired("Section", sectionName.Section);
}
static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) { static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
commonSectionMapping(IO, Section); commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries); IO.mapOptional("Entries", Section.Entries);
} }
static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) { static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
commonSectionMapping(IO, Section); commonSectionMapping(IO, Section);
IO.mapOptional("Version", Section.Version, Hex16(0)); IO.mapOptional("Version", Section.Version, Hex16(0));
▲ Show 20 Lines • Show All 389 Lines • Show Last 20 Lines

llvm/test/DebugInfo/symbolize-build-id-error.test

Show All 11 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .note.invalid - Name: .note.invalid
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: 0123456789 Content: 0123456789
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .note.invalid
- Section: .note.invalid LastSec: .note.invalid

llvm/test/DebugInfo/symbolize-build-id.test

Show All 16 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .note.gnu.build-id - Name: .note.gnu.build-id
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: 040000000800000003000000474e5500abb50d82b6bdc861 Content: 040000000800000003000000474e5500abb50d82b6bdc861
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .note.gnu.build-id
- Section: .note.gnu.build-id LastSec: .note.gnu.build-id

llvm/test/Object/invalid.test

Show First 20 Lines • Show All 444 Lines • ▼ Show 20 Lines - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Address: 0x1000 Address: 0x1000
Entries: Entries:
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0xFFFF0000 Value: 0xFFFF0000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Check that llvm-readobj reports a warning when a dynamic relocation section ## Check that llvm-readobj reports a warning when a dynamic relocation section
## has sh_entsize field with size != sizeof(Elf_Rela). ## has sh_entsize field with size != sizeof(Elf_Rela).
# RUN: llvm-readobj --dyn-relocations \ # RUN: llvm-readobj --dyn-relocations \
# RUN: %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 \ # RUN: %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 \
# RUN: | FileCheck -DFILE=%p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 --check-prefix=RELOC-BROKEN-ENTSIZE %s # RUN: | FileCheck -DFILE=%p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 --check-prefix=RELOC-BROKEN-ENTSIZE %s
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 LinesSections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Entries: Entries:
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
FileSize: 0xffff0000 FileSize: 0xffff0000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# RUN: yaml2obj --docnum=24 %s -o %t24 # RUN: yaml2obj --docnum=24 %s -o %t24
# RUN: not obj2yaml 2>&1 %t24 | FileCheck %s -DFILE=%t24 --check-prefix=INVALID-SHSTRNDX # RUN: not obj2yaml 2>&1 %t24 | FileCheck %s -DFILE=%t24 --check-prefix=INVALID-SHSTRNDX
# INVALID-SHSTRNDX: Error reading file: [[FILE]]: section header string table index 255 does not exist # INVALID-SHSTRNDX: Error reading file: [[FILE]]: section header string table index 255 does not exist
--- !ELF --- !ELF
FileHeader: FileHeader:
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/test/Object/obj2yaml.test

Show First 20 Lines • Show All 654 Lines • ▼ Show 20 Lines
# ELF-AVR: FileHeader: # ELF-AVR: FileHeader:
# ELF-AVR-NEXT: Class: ELFCLASS32 # ELF-AVR-NEXT: Class: ELFCLASS32
# ELF-AVR-NEXT: Data: ELFDATA2LSB # ELF-AVR-NEXT: Data: ELFDATA2LSB
# ELF-AVR-NEXT: Type: ET_EXEC # ELF-AVR-NEXT: Type: ET_EXEC
# ELF-AVR-NEXT: Machine: EM_AVR # ELF-AVR-NEXT: Machine: EM_AVR
# ELF-AVR-NEXT: Flags: [ EF_AVR_ARCH_AVR2 ] # ELF-AVR-NEXT: Flags: [ EF_AVR_ARCH_AVR2 ]
# ELF-AVR-NEXT: ProgramHeaders: # ELF-AVR-NEXT: ProgramHeaders:
# ELF-AVR-NEXT: - Type: PT_LOAD # ELF-AVR-NEXT: - Type: PT_LOAD
# ELF-AVR-NEXT: Flags: [ PF_X, PF_R ] # ELF-AVR-NEXT: Flags: [ PF_X, PF_R ]
# ELF-AVR-NEXT: Sections: # ELF-AVR-NEXT: FirstSec: .text
# ELF-AVR-NEXT: - Section: .text # ELF-AVR-NEXT: LastSec: .text
# ELF-AVR-NEXT: Align: 0x0000000000000002 # ELF-AVR-NEXT: Align: 0x0000000000000002
# ELF-AVR-NEXT: - Type: PT_LOAD # ELF-AVR-NEXT: - Type: PT_LOAD
# ELF-AVR-NEXT: Flags: [ PF_W, PF_R ] # ELF-AVR-NEXT: Flags: [ PF_W, PF_R ]
# ELF-AVR-NEXT: Sections: # ELF-AVR-NEXT: FirstSec: .data
# ELF-AVR-NEXT: - Section: .data # ELF-AVR-NEXT: LastSec: .data
# ELF-AVR-NEXT: VAddr: 0x0000000000800060 # ELF-AVR-NEXT: VAddr: 0x0000000000800060
# ELF-AVR-NEXT: PAddr: 0x0000000000000004 # ELF-AVR-NEXT: PAddr: 0x0000000000000004
# ELF-AVR-NEXT: Sections: # ELF-AVR-NEXT: Sections:
# ELF-AVR-NEXT: - Name: .text # ELF-AVR-NEXT: - Name: .text
# ELF-AVR-NEXT: Type: SHT_PROGBITS # ELF-AVR-NEXT: Type: SHT_PROGBITS
# ELF-AVR-NEXT: Flags: [ SHF_ALLOC, SHF_EXECINSTR ] # ELF-AVR-NEXT: Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
# ELF-AVR-NEXT: AddressAlign: 0x0000000000000002 # ELF-AVR-NEXT: AddressAlign: 0x0000000000000002
# ELF-AVR-NEXT: Content: C20E0895 # ELF-AVR-NEXT: Content: C20E0895
# ELF-AVR-NEXT: - Name: .data # ELF-AVR-NEXT: - Name: .data
# ELF-AVR-NEXT: Type: SHT_PROGBITS # ELF-AVR-NEXT: Type: SHT_PROGBITS
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/test/tools/llvm-elfabi/binary-read-add-soname.test

Show All 24 Lines Entries:
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: --- !tapi-tbe # CHECK: --- !tapi-tbe
# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}} # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
# CHECK-NEXT: SoName: best.so{{$}} # CHECK-NEXT: SoName: best.so{{$}}
# CHECK-NEXT: Arch: AArch64 # CHECK-NEXT: Arch: AArch64
# CHECK-NEXT: Symbols: {} # CHECK-NEXT: Symbols: {}
# CHECK-NEXT: ... # CHECK-NEXT: ...

llvm/test/tools/llvm-elfabi/binary-read-arch.test

Show All 24 Lines Entries:
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: --- !tapi-tbe # CHECK: --- !tapi-tbe
# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}} # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
# CHECK-NEXT: Arch: x86_64 # CHECK-NEXT: Arch: x86_64
# CHECK-NEXT: Symbols: {} # CHECK-NEXT: Symbols: {}
# CHECK-NEXT: ... # CHECK-NEXT: ...

llvm/test/tools/llvm-elfabi/binary-read-bad-soname.test

Show All 26 Lines Entries:
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: DT_SONAME string offset (0x000000000000000d) outside of dynamic string table # CHECK: DT_SONAME string offset (0x000000000000000d) outside of dynamic string table

llvm/test/tools/llvm-elfabi/binary-read-bad-vaddr.test

Show All 26 Lines Entries:
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000000260 # Bad vaddr (no PT_LOAD for 0x0000 to 0x0FFF) Value: 0x0000000000000260 # Bad vaddr (no PT_LOAD for 0x0000 to 0x0FFF)
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1008 VAddr: 0x1008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: virtual address is not in any segment: 0x260 when locating .dynstr section contents # CHECK: virtual address is not in any segment: 0x260 when locating .dynstr section contents

llvm/test/tools/llvm-elfabi/binary-read-neededlibs-bad-offset.test

Show All 30 Lines Entries:
Value: 0x0000000000000024 Value: 0x0000000000000024
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1024 VAddr: 0x1024
Sections:
# CHECK: DT_NEEDED string offset (0x000000000000ffff) outside of dynamic string table # CHECK: DT_NEEDED string offset (0x000000000000ffff) outside of dynamic string table

llvm/test/tools/llvm-elfabi/binary-read-neededlibs.test

Show All 29 Lines Entries:
Value: 0x0000000000000024 Value: 0x0000000000000024
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1024 VAddr: 0x1024
Sections:
# CHECK: NeededLibs: # CHECK: NeededLibs:
# CHECK-NEXT: - libfoo.so{{$}} # CHECK-NEXT: - libfoo.so{{$}}
# CHECK-NEXT: - libbar.so{{$}} # CHECK-NEXT: - libbar.so{{$}}
# CHECK-NEXT: Symbols: {} # CHECK-NEXT: Symbols: {}

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strsz.test

Show All 21 Lines - Name: .dynamic
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
EntSize: 0x0000000000000010 EntSize: 0x0000000000000010
Entries: Entries:
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: Couldn't determine dynamic string table size (no DT_STRSZ entry) # CHECK: Couldn't determine dynamic string table size (no DT_STRSZ entry)

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strtab.test

Show All 20 Lines - Name: .dynamic
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
EntSize: 0x0000000000000010 EntSize: 0x0000000000000010
Entries: Entries:
- Tag: DT_STRSZ - Tag: DT_STRSZ
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: Couldn't locate dynamic string table (no DT_STRTAB entry) # CHECK: Couldn't locate dynamic string table (no DT_STRTAB entry)

llvm/test/tools/llvm-elfabi/binary-read-replace-soname.test

Show All 28 Lines Entries:
Value: 0x0000000000000014 Value: 0x0000000000000014
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1018 VAddr: 0x1018
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# ORIGINAL: SoName: somelib.so{{$}} # ORIGINAL: SoName: somelib.so{{$}}
# REPLACED: SoName: libbest.so{{$}} # REPLACED: SoName: libbest.so{{$}}

llvm/test/tools/llvm-elfabi/binary-read-soname-no-null.test

Show All 27 Lines Entries:
Value: 0x000000000000000F Value: 0x000000000000000F
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1018 VAddr: 0x1018
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: String overran bounds of string table (no null terminator) when reading DT_SONAME # CHECK: String overran bounds of string table (no null terminator) when reading DT_SONAME

llvm/test/tools/llvm-elfabi/binary-read-soname.test

Show All 27 Lines Entries:
Value: 0x0000000000000014 Value: 0x0000000000000014
- Tag: DT_STRTAB - Tag: DT_STRTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0x0000000000001000 Value: 0x0000000000001000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 8 Align: 8
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1018 VAddr: 0x1018
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# CHECK: --- !tapi-tbe # CHECK: --- !tapi-tbe
# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}} # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
# CHECK-NEXT: SoName: somelib.so{{$}} # CHECK-NEXT: SoName: somelib.so{{$}}
# CHECK-NEXT: Arch: x86_64 # CHECK-NEXT: Arch: x86_64
# CHECK-NEXT: Symbols: {} # CHECK-NEXT: Symbols: {}
# CHECK-NEXT: ... # CHECK-NEXT: ...

llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines - Name: .debug_str
AddressAlign: 0x0000000000000001 AddressAlign: 0x0000000000000001
EntSize: 0x0000000000000001 EntSize: 0x0000000000000001
Content: 61726776002F746D70006D61696E006D61696E2E637070006172676300474E5520432B2B20342E382E3520323031353036323320285265642048617420342E382E352D333629202D6D74756E653D67656E65726963202D6D617263683D7838362D3634202D67202D4F30006368617200 Content: 61726776002F746D70006D61696E006D61696E2E637070006172676300474E5520432B2B20342E382E3520323031353036323320285265642048617420342E382E352D333629202D6D74756E653D67656E65726963202D6D617263683D7838362D3634202D67202D4F30006368617200
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0000000000400000 VAddr: 0x0000000000400000
Align: 1024 Align: 1024
Sections: FirstSec: .interp
- Section: .interp LastSec: .dynstr
- Section: .interp
- Section: .note.ABI-tag
- Section: .note.gnu.build-id
- Section: .gnu.hash
- Section: .gnu.version
- Section: .gnu.version_r
- Section: .rela.dyn
- Section: .rela.plt
- Section: .init
- Section: .plt
- Section: .plt.got
- Section: .text
- Section: .fini
- Section: .rodata
- Section: .eh_frame_hdr
- Section: .eh_frame
- Section: .dynsym
- Section: .dynstr
Symbols: Symbols:
- Name: .interp - Name: .interp
Type: STT_SECTION Type: STT_SECTION
Section: .interp Section: .interp
Value: 0x0000000000400238 Value: 0x0000000000400238
- Name: .note.ABI-tag - Name: .note.ABI-tag
Type: STT_SECTION Type: STT_SECTION
Section: .note.ABI-tag Section: .note.ABI-tag
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/Inputs/ihex-elf-pt-null.yaml

!ELF !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x0 Address: 0x0
AddressAlign: 0x8 AddressAlign: 0x8
Content: "0001020304" Content: "0001020304"
ProgramHeaders: ProgramHeaders:
- Type: PT_NULL - Type: PT_NULL
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xF00000000 VAddr: 0xF00000000
PAddr: 0x100000 PAddr: 0x100000
Sections: FirstSec: .text
- Section: .text LastSec: .text

llvm/test/tools/llvm-objcopy/ELF/Inputs/ihex-elf-segments.yaml

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines - Name: .bss
AddressAlign: 0x8 AddressAlign: 0x8
- Name: .dummy - Name: .dummy
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ ] Flags: [ ]
Address: 0x20FFF8 Address: 0x20FFF8
Size: 65536 Size: 65536
AddressAlign: 0x8 AddressAlign: 0x8
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xF00000000 VAddr: 0xF00000000
PAddr: 0x100000 PAddr: 0x100000
Sections: FirstSec: .text
- Section: .text LastSec: .bss
- Section: .data1
- Section: .data2
- Section: .data3
- Section: .bss

llvm/test/tools/llvm-objcopy/ELF/add-symbol.test

Show All 38 Lines - Name: .text
Size: 64 Size: 64
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x2000 Address: 0x2000
AddressAlign: 0x0000000000001000 AddressAlign: 0x0000000000001000
Size: 64 Size: 64
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x2000 VAddr: 0x2000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .data
- Section: .data LastSec: .data
## TODO (grimar): llvm-objcopy seems produce a broken output without ## TODO (grimar): llvm-objcopy seems produce a broken output without
## the following line, i.e. when there is no symbol table in the input. ## the following line, i.e. when there is no symbol table in the input.
Symbols: [] Symbols: []
# CHECK: 0: 00000000 0 NOTYPE LOCAL DEFAULT UND # CHECK: 0: 00000000 0 NOTYPE LOCAL DEFAULT UND
# CHECK-NEXT: 1: 00000001 0 NOTYPE GLOBAL DEFAULT ABS abs1 # CHECK-NEXT: 1: 00000001 0 NOTYPE GLOBAL DEFAULT ABS abs1
# CHECK-NEXT: 2: 00000002 0 FUNC LOCAL HIDDEN ABS abs2 # CHECK-NEXT: 2: 00000002 0 FUNC LOCAL HIDDEN ABS abs2
# CHECK-NEXT: 3: 00000003 0 OBJECT GLOBAL DEFAULT ABS abs3 # CHECK-NEXT: 3: 00000003 0 OBJECT GLOBAL DEFAULT ABS abs3
Show All 15 Lines

llvm/test/tools/llvm-objcopy/ELF/adjacent-segments.test

Show All 17 Lines - Name: .text
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 24 Size: 24
- Name: .text2 - Name: .text2
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x10 AddressAlign: 0x10
Size: 16 Size: 16
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text2
- Section: .text2 LastSec: .text2
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD (0x1) #CHECK-NEXT: Type: PT_LOAD (0x1)
#CHECK-NEXT: Offset: 0x1000 #CHECK-NEXT: Offset: 0x1000
#CHECK-NEXT: VirtualAddress: 0x0 #CHECK-NEXT: VirtualAddress: 0x0
#CHECK-NEXT: PhysicalAddress: 0x0 #CHECK-NEXT: PhysicalAddress: 0x0
#CHECK-NEXT: FileSize: 24 #CHECK-NEXT: FileSize: 24
Show All 21 Lines

llvm/test/tools/llvm-objcopy/ELF/bad-build-id.test

Show All 9 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .note.gnu.build-id - Name: .note.gnu.build-id
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: 040000000100000003000000474E55004F000000 Content: 040000000100000003000000474E55004F000000
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .note.gnu.build-id
- Section: .note.gnu.build-id LastSec: .note.gnu.build-id

llvm/test/tools/llvm-objcopy/ELF/basic-binary-copy.test

Show All 10 LinesFileHeader:
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x0000000000001000 AddressAlign: 0x0000000000001000
Content: "c3c3c3c3" Content: "c3c3c3c3"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text
# CHECK: 0000000 c3c3 c3c3 # CHECK: 0000000 c3c3 c3c3
# SIZE: 4 # SIZE: 4

llvm/test/tools/llvm-objcopy/ELF/binary-first-seg-offset-zero.test

Show All 17 Lines - Name: .note
Size: 32 Size: 32
- Name: .rodata - Name: .rodata
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Type: SHT_PROGBITS Type: SHT_PROGBITS
Address: 0x1020 Address: 0x1020
Size: 4064 Size: 4064
Content: "DEADBEEF" Content: "DEADBEEF"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .note
- Section: .note LastSec: .rodata
- Section: .rodata
# CHECK: 000000 de ad be ef # CHECK: 000000 de ad be ef

llvm/test/tools/llvm-objcopy/ELF/binary-no-paddr.test

Show All 26 Lines - Name: .text
Content: "c3c3c3c3" Content: "c3c3c3c3"
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x1004 Address: 0x1004
AddressAlign: 0x0000000000000004 AddressAlign: 0x0000000000000004
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
PAddr: [[PADDR]] PAddr: [[PADDR]]
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x1004 VAddr: 0x1004
PAddr: [[PADDR]] PAddr: [[PADDR]]
Sections: FirstSec: .data
- Section: .data LastSec: .data
# CHECK: 0000000 3232 c3c3 # CHECK: 0000000 3232 c3c3
# SIZE: 4 # SIZE: 4

llvm/test/tools/llvm-objcopy/ELF/binary-paddr.test

Show All 29 Lines - Name: .text
Content: "c3c3c3c3" Content: "c3c3c3c3"
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_WRITE ] Flags: [ SHF_ALLOC, SHF_WRITE ]
Address: 0x2000 Address: 0x2000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
Sections: FirstSec: .text
- Section: .text LastSec: .data
- Section: .data
## The computed LMA of a section not in a PT_LOAD equals its sh_addr. ## The computed LMA of a section not in a PT_LOAD equals its sh_addr.
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: llvm-objcopy -O binary %t2 %t2.out # RUN: llvm-objcopy -O binary %t2 %t2.out
# RUN: od -A x -t x2 %t2.out | FileCheck %s --check-prefix=CHECK2 --ignore-case # RUN: od -A x -t x2 %t2.out | FileCheck %s --check-prefix=CHECK2 --ignore-case
# RUN: wc -c %t2.out | FileCheck %s --check-prefix=SIZE2 # RUN: wc -c %t2.out | FileCheck %s --check-prefix=SIZE2
Show All 22 LinesSections:
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_WRITE ] Flags: [ SHF_ALLOC, SHF_WRITE ]
## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x4000 = 0x4000. ## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x4000 = 0x4000.
Address: 0x2000 Address: 0x2000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x2000 VAddr: 0x2000
## p_vaddr is increased from 0x2000 to 0x4000. ## p_vaddr is increased from 0x2000 to 0x4000.
PAddr: 0x4000 PAddr: 0x4000
Sections: FirstSec: .data
- Section: .data LastSec: .data
## Check that we use sh_offset instead of sh_addr to decide where to write section contents. ## Check that we use sh_offset instead of sh_addr to decide where to write section contents.
# RUN: yaml2obj --docnum=3 %s -o %t3 # RUN: yaml2obj --docnum=3 %s -o %t3
# RUN: llvm-objcopy -O binary %t3 %t3.out # RUN: llvm-objcopy -O binary %t3 %t3.out
# RUN: od -A x -t x2 %t3.out | FileCheck %s --check-prefix=CHECK3 --ignore-case # RUN: od -A x -t x2 %t3.out | FileCheck %s --check-prefix=CHECK3 --ignore-case
# RUN: wc -c %t3.out | FileCheck %s --check-prefix=SIZE3 # RUN: wc -c %t3.out | FileCheck %s --check-prefix=SIZE3
Show All 23 Lines - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_WRITE ] Flags: [ SHF_ALLOC, SHF_WRITE ]
## sh_addr is increased from 0x2000 to 0x3000, but it is ignored. ## sh_addr is increased from 0x2000 to 0x3000, but it is ignored.
## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x3000 = 0x3000. ## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x3000 = 0x3000.
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .data
- Section: .data LastSec: .data
## The first section (.text) is empty. Test that we skip its LMA until the first ## The first section (.text) is empty. Test that we skip its LMA until the first
## non-empty section, otherwise we would leave a large number of leading zeroes. ## non-empty section, otherwise we would leave a large number of leading zeroes.
# RUN: yaml2obj --docnum=4 %s -o %t4 # RUN: yaml2obj --docnum=4 %s -o %t4
# RUN: llvm-objcopy -O binary %t4 %t4.out # RUN: llvm-objcopy -O binary %t4 %t4.out
# RUN: od -A x -t x2 %t4.out | FileCheck %s --check-prefix=SKIPEMPTY # RUN: od -A x -t x2 %t4.out | FileCheck %s --check-prefix=SKIPEMPTY
# SKIPEMPTY: 000000 3232 # SKIPEMPTY: 000000 3232
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/binary-remove-all-but-one.test

Show All 26 LinesSections:
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "32323232" Content: "32323232"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text3
- Section: .text2
- Section: .text3
# CHECK: 000000 de ad be ef # CHECK: 000000 de ad be ef
# SIZE: 4096 # SIZE: 4096

llvm/test/tools/llvm-objcopy/ELF/binary-remove-end.test

Show All 26 LinesSections:
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "32323232" Content: "32323232"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text3
- Section: .text2
- Section: .text3
# CHECK: 000000 c3 c3 c3 c3 # CHECK: 000000 c3 c3 c3 c3
# CHECK: 001000 de ad be ef # CHECK: 001000 de ad be ef
# SIZE: 8192 # SIZE: 8192

llvm/test/tools/llvm-objcopy/ELF/binary-remove-middle.test

Show All 26 LinesSections:
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "32323232" Content: "32323232"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text3
- Section: .text2
- Section: .text3
# CHECK: 000000 c3 c3 c3 c3 # CHECK: 000000 c3 c3 c3 c3
# CHECK: 001000 00 00 00 00 # CHECK: 001000 00 00 00 00
# CHECK: 002000 32 32 32 32 # CHECK: 002000 32 32 32 32
# SIZE: 12288 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/binary-segment-layout.test

Show All 17 Lines - Name: .text
Content: "c3c3c3c3" Content: "c3c3c3c3"
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
Address: 0x08 Address: 0x08
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x00 VAddr: 0x00
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x08 VAddr: 0x08
Sections: FirstSec: .data
- Section: .data LastSec: .data
# CHECK: 0000000 c3c3 c3c3 0000 0000 3232 # CHECK: 0000000 c3c3 c3c3 0000 0000 3232
# SIZE: 10 # SIZE: 10

llvm/test/tools/llvm-objcopy/ELF/build-id-link-dir.test

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .note.gnu.build-id - Name: .note.gnu.build-id
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .note.gnu.build-id
- Section: .note.gnu.build-id LastSec: .note.gnu.build-id

llvm/test/tools/llvm-objcopy/ELF/check-addr-offset-align-binary.test

Show All 16 Lines - Name: .text
Content: "c3c3c3c3" Content: "c3c3c3c3"
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x1008 Address: 0x1008
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x1008 VAddr: 0x1008
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .data
- Section: .data LastSec: .data
# CHECK: 0000000 c3 c3 c3 c3 00 00 00 00 32 32 # CHECK: 0000000 c3 c3 c3 c3 00 00 00 00 32 32

llvm/test/tools/llvm-objcopy/ELF/check-addr-offset-align.test

Show All 16 Lines - Name: .text
Content: "c3c3c3c3" Content: "c3c3c3c3"
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x1008 Address: 0x1008
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
Content: "3232" Content: "3232"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x1008 VAddr: 0x1008
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .data
- Section: .data LastSec: .data
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD #CHECK-NEXT: Type: PT_LOAD
#CHECK-NEXT: Offset: 0x1000 #CHECK-NEXT: Offset: 0x1000
#CHECK-NEXT: VirtualAddress: 0x1000 #CHECK-NEXT: VirtualAddress: 0x1000
#CHECK-NEXT: PhysicalAddress: 0x1000 #CHECK-NEXT: PhysicalAddress: 0x1000
#CHECK-NEXT: FileSize: 4 #CHECK-NEXT: FileSize: 4
Show All 21 Lines

llvm/test/tools/llvm-objcopy/ELF/copy-after-strip-sections.test

Show All 15 LinesFileHeader:
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Content: 'facefeed' Content: 'facefeed'
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .text
- Section: .text LastSec: .text

llvm/test/tools/llvm-objcopy/ELF/dump-section.test

Show All 29 Lines - Name: .foo
Content: "CAFE" Content: "CAFE"
- Name: .empty - Name: .empty
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
- Name: .bar - Name: .bar
Type: SHT_NOBITS Type: SHT_NOBITS
Flags: [ SHF_WRITE ] Flags: [ SHF_WRITE ]
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text
# CHECK: 0000000 de ad be ef # CHECK: 0000000 de ad be ef
# NON-ALLOC: 0000000 ca fe # NON-ALLOC: 0000000 ca fe
# SIZE: 4 # SIZE: 4
# NOBITS: error: '[[INPUT]]': cannot dump section '.bar': it has no contents # NOBITS: error: '[[INPUT]]': cannot dump section '.bar': it has no contents
# EMPTY: 0 # EMPTY: 0

llvm/test/tools/llvm-objcopy/ELF/empty-section.test

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines - Name: .empty
Address: 0x1000 Address: 0x1000
- Name: .baz - Name: .baz
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
AddressAlign: 0x1000 AddressAlign: 0x1000
Address: 0x1000 Address: 0x1000
Size: 0x100 Size: 0x100
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0 VAddr: 0
Align: 0x100 Align: 0x100
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .empty
- Section: .empty LastSec: .baz
- Section: .baz

llvm/test/tools/llvm-objcopy/ELF/identical-segments.test

Show All 18 Lines - Name: .text
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
- Name: .text2 - Name: .text2
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text2
- Section: .text2 LastSec: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD (0x1) #CHECK-NEXT: Type: PT_LOAD (0x1)
#CHECK-NEXT: Offset: 0x2000 #CHECK-NEXT: Offset: 0x2000
#CHECK-NEXT: VirtualAddress: 0x0 #CHECK-NEXT: VirtualAddress: 0x0
#CHECK-NEXT: PhysicalAddress: 0x0 #CHECK-NEXT: PhysicalAddress: 0x0
#CHECK-NEXT: FileSize: 4096 #CHECK-NEXT: FileSize: 4096
Show All 34 Lines

llvm/test/tools/llvm-objcopy/ELF/invalid-p_filesz-p_offset.test

Show All 10 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
FileSize: 0x100000 FileSize: 0x100000
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
## A similar case, but now the p_offset property of the program header is too large. ## A similar case, but now the p_offset property of the program header is too large.
# RUN: yaml2obj --docnum=2 %s -o %t2.o # RUN: yaml2obj --docnum=2 %s -o %t2.o
# RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s --check-prefix=ERR2 # RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s --check-prefix=ERR2
# ERR2: error: program header with offset 0x100000 and file size 0x1 goes past the end of the file # ERR2: error: program header with offset 0x100000 and file size 0x1 goes past the end of the file
--- !ELF --- !ELF
Show All 9 Lines

llvm/test/tools/llvm-objcopy/ELF/marker-segment.test

Show All 23 LinesSections:
- Name: .xdata - Name: .xdata
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
- Name: .after - Name: .after
Type: SHT_NOBITS Type: SHT_NOBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 64 Size: 64
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x2000 VAddr: 0x2000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .data
- Section: .data LastSec: .data
- Type: PT_GNU_STACK - Type: PT_GNU_STACK
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x0000 VAddr: 0x0000
Align: 0x0000 Align: 0x0000
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x2010 VAddr: 0x2010
Sections: FirstSec: .xdata
- Section: .xdata LastSec: .after
- Section: .after
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD #CHECK-NEXT: Type: PT_LOAD
#CHECK-NEXT: Offset: 0x1000 #CHECK-NEXT: Offset: 0x1000
#CHECK-NEXT: VirtualAddress: 0x1000 #CHECK-NEXT: VirtualAddress: 0x1000
#CHECK-NEXT: PhysicalAddress: 0x1000 #CHECK-NEXT: PhysicalAddress: 0x1000
#CHECK-NEXT: FileSize: 16 #CHECK-NEXT: FileSize: 16
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/no-build-id.test

Show All 9 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: 000000000000000000000000 Content: 000000000000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 LinesSections:
- Name: .debug_info - Name: .debug_info
Type: SHT_PROGBITS Type: SHT_PROGBITS
Content: 05 Content: 05
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Offset: 0 Offset: 0
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .note1
- Section: .note1 LastSec: .text
- Section: .note2
- Section: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x1480 # Ensure Offset=VAddr (mod Align) if Offset changes VAddr: 0x1480 # Ensure Offset=VAddr (mod Align) if Offset changes
Align: 0x1000 Align: 0x1000
Sections: FirstSec: .tdata
- Section: .tdata LastSec: .bss
- Section: .bss
- Type: PT_TLS - Type: PT_TLS
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x1480 # Ensure Offset=VAddr (mod Align) if Offset changes VAddr: 0x1480 # Ensure Offset=VAddr (mod Align) if Offset changes
Sections: FirstSec: .tdata
- Section: .tdata LastSec: .tbss
- Section: .tbss
- Type: PT_NOTE - Type: PT_NOTE
VAddr: 0x400 VAddr: 0x400
Sections: FirstSec: .note1
- Section: .note1 LastSec: .note2
- Section: .note2
... ...
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: llvm-objcopy --only-keep-debug %t2 %t2.dbg # RUN: llvm-objcopy --only-keep-debug %t2 %t2.dbg
# RUN: llvm-readelf -S -l %t2.dbg | FileCheck --check-prefix=CHECK2 %s # RUN: llvm-readelf -S -l %t2.dbg | FileCheck --check-prefix=CHECK2 %s
## Only the tail of a segment can be trimmed. .text still occupies space because ## Only the tail of a segment can be trimmed. .text still occupies space because
## it is followed by .note which is not SHT_NOBITS. ## it is followed by .note which is not SHT_NOBITS.
Show All 40 Lines - Type: PT_PHDR
# 3 * sizeof(Elf64_Phdr) = 0xa8 # 3 * sizeof(Elf64_Phdr) = 0xa8
FileSize: 0xa8 FileSize: 0xa8
MemSize: 0xa8 MemSize: 0xa8
Align: 8 Align: 8
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Offset: 0 Offset: 0
Align: 4096 Align: 4096
Sections: FirstSec: .text
- Section: .text LastSec: .note
- Section: .note
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
Offset: 0x202 Offset: 0x202
VAddr: 0x202 VAddr: 0x202
FileSize: 14 FileSize: 14
MemSize: 14 MemSize: 14
... ...
Show All 36 Lines

llvm/test/tools/llvm-objcopy/ELF/overlap-chain.test

Show All 34 Lines - Name: .text4
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
- Name: .text5 - Name: .text5
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text4
- Section: .text4 LastSec: .text5
- Section: .text5
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text4
- Section: .text4
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text2
- Section: .text2 LastSec: .text3
- Section: .text3
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD (0x1) #CHECK-NEXT: Type: PT_LOAD (0x1)
#CHECK-NEXT: Offset: 0x1000 #CHECK-NEXT: Offset: 0x1000
#CHECK-NEXT: VirtualAddress: 0x0 #CHECK-NEXT: VirtualAddress: 0x0
#CHECK-NEXT: PhysicalAddress: 0x0 #CHECK-NEXT: PhysicalAddress: 0x0
#CHECK-NEXT: FileSize: 8192 #CHECK-NEXT: FileSize: 8192
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/parent-loop-check.test

Show All 27 Lines - Name: .note
Size: 32 Size: 32
- Name: .rodata - Name: .rodata
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Type: SHT_PROGBITS Type: SHT_PROGBITS
Address: 0x1020 Address: 0x1020
Size: 4064 Size: 4064
Content: "DEADBEEF" Content: "DEADBEEF"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .note
- Section: .note LastSec: .rodata
- Section: .rodata
- Type: PT_NOTE - Type: PT_NOTE
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .note
- Section: .note LastSec: .note
# CHECK: 000000 de ad be ef # CHECK: 000000 de ad be ef

llvm/test/tools/llvm-objcopy/ELF/preserve-segment-contents-ehdr-phdrs.test

Show All 31 LinesSections:
- Name: .keep_me - Name: .keep_me
Type: SHT_PROGBITS Type: SHT_PROGBITS
Size: 0x10 Size: 0x10
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Offset: 0 Offset: 0
FileSize: 176 # sizeof(Elf64_Ehdr) + 2 * sizeof(Elf64_Phdr) FileSize: 176 # sizeof(Elf64_Ehdr) + 2 * sizeof(Elf64_Phdr)
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .keep_me
- Section: .keep_me LastSec: .keep_me
Symbols: [] Symbols: []

llvm/test/tools/llvm-objcopy/ELF/preserve-segment-contents.test

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Lines - Name: sectiong
Content: '44444444' Content: '44444444'
Address: 0x5034 Address: 0x5034
- Name: blobh - Name: blobh
Type: SHT_PROGBITS Type: SHT_PROGBITS
Content: 'abbababa' Content: 'abbababa'
Address: 0x5038 Address: 0x5038
ProgramHeaders: ProgramHeaders:
# First segment has unlabelled space at start and end. # First segment has unlabelled space at start and end.
- Type: 0x6ABCDEF0 # Non-specific segment type. - Type: 0x6ABCDEF0 # Non-specific segment type.
VAddr: 0x2000 VAddr: 0x2000
Align: 0x2000 Align: 0x2000
Sections: FirstSec: blob1
- Section: blob1 LastSec: blob4
- Section: section1
- Section: blob2
- Section: section2 # nobits
- Section: blob3
- Section: section3
- Section: blob4
# Second segment has sections at start and end. # Second segment has sections at start and end.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x2100 VAddr: 0x2100
Align: 0x100 Align: 0x100
Sections: FirstSec: section4
- Section: section4 LastSec: section5
- Section: blob5
- Section: section5
# Third segment is all covered by a section. # Third segment is all covered by a section.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x2200 VAddr: 0x2200
Align: 0x100 Align: 0x100
Sections: FirstSec: section6
- Section: section6 LastSec: section6
# Fourth segment has no sections (after removing blob headers). # Fourth segment has no sections (after removing blob headers).
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x2300 VAddr: 0x2300
Align: 0x100 Align: 0x100
Sections: FirstSec: blob6
- Section: blob6 LastSec: blob6
# Fifth segment is empty. # Fifth segment is empty.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x2308 VAddr: 0x2308
Offset: 0x2308 Offset: 0x2308
# The next few segments test behaviour of fully nested segments. # The next few segments test behaviour of fully nested segments.
# Sixth segment is the "parent" segment. # Sixth segment is the "parent" segment.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x3000 VAddr: 0x3000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: sectionA
- Section: sectionA LastSec: sectionI
- Section: sectionB
- Section: blobA
- Section: sectionC
- Section: blobB
- Section: sectionD
- Section: blobC
- Section: sectionE
- Section: blobD
- Section: sectionF
- Section: blobE
- Section: blobF
- Section: sectionG
- Section: blobG
- Section: sectionH
- Section: blobH
- Section: sectionI
# Seventh segment is empty and nested. # Seventh segment is empty and nested.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x3002 VAddr: 0x3002
Offset: 0x3002 Offset: 0x3002
# Eighth segment contains only a section and is nested. # Eighth segment contains only a section and is nested.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x3004 VAddr: 0x3004
Sections: FirstSec: sectionB
- Section: sectionB LastSec: sectionB
# Ninth segment contains only unlabelled space and is nested. # Ninth segment contains only unlabelled space and is nested.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x3008 VAddr: 0x3008
Sections: FirstSec: blobA
- Section: blobA LastSec: blobA
# Tenth segment contains two sections with space between and is nested. # Tenth segment contains two sections with space between and is nested.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x300C VAddr: 0x300C
Sections: FirstSec: sectionC
- Section: sectionC LastSec: sectionD
- Section: blobB
- Section: sectionD
# Eleventh segment contains two sections with space between and at ends and is nested. # Eleventh segment contains two sections with space between and at ends and is nested.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x3018 VAddr: 0x3018
Sections: FirstSec: blobC
- Section: blobC LastSec: blobE
- Section: sectionE
- Section: blobD
- Section: sectionF
- Section: blobE
# Twelfth segment contains one section with space at ends adjacent to space in parent segment. # Twelfth segment contains one section with space at ends adjacent to space in parent segment.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x302E VAddr: 0x302E
Offset: 0x302E Offset: 0x302E
FileSize: 8 FileSize: 8
Sections: FirstSec: sectionG
- Section: sectionG LastSec: sectionG
# Thirteenth segment contains overlaps sections at either end in parent segment. # Thirteenth segment contains overlaps sections at either end in parent segment.
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x303A VAddr: 0x303A
Offset: 0x303A Offset: 0x303A
FileSize: 0x8 FileSize: 0x8
Sections: FirstSec: blobH
- Section: blobH LastSec: blobH
# The next batch of segments are segments that only partially overlap other segments. # The next batch of segments are segments that only partially overlap other segments.
# Segment14: |-unlabelled-|-Sec-| # Segment14: |-unlabelled-|-Sec-|
# Segment15: |--|-Sec-|-unlabelled-| # Segment15: |--|-Sec-|-unlabelled-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4000 VAddr: 0x4000
Sections: FirstSec: blobz
- Section: blobz LastSec: sectionz
- Section: sectionz
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4002 VAddr: 0x4002
Offset: 0x4002 Offset: 0x4002
Sections: FirstSec: sectionz
- Section: sectionz LastSec: bloby
- Section: bloby
# Segment16: |-Sec-|--| # Segment16: |-Sec-|--|
# Segment17: |--|----unlabelled---| # Segment17: |--|----unlabelled---|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x400C VAddr: 0x400C
FileSize: 6 FileSize: 6
Sections: FirstSec: sectiony
- Section: sectiony LastSec: sectiony
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x400E VAddr: 0x400E
Offset: 0x400E Offset: 0x400E
Sections: FirstSec: blobx
- Section: blobx LastSec: blobx
# Segment18: |-unlabelled-|-Sec-| # Segment18: |-unlabelled-|-Sec-|
# Segment19: |-Sec-|-unlabelled-| # Segment19: |-Sec-|-unlabelled-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4014 VAddr: 0x4014
Sections: FirstSec: blobw
- Section: blobw LastSec: sectionx
- Section: sectionx
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4018 VAddr: 0x4018
Sections: FirstSec: sectionx
- Section: sectionx LastSec: blobv
- Section: blobv
# Segment20: |-Sec-| # Segment20: |-Sec-|
# Segment21: |--|-unlabelled-|-Sec-| # Segment21: |--|-unlabelled-|-Sec-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4020 VAddr: 0x4020
Sections: FirstSec: sectionw
- Section: sectionw LastSec: sectionw
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4022 VAddr: 0x4022
Offset: 0x4022 Offset: 0x4022
Sections: FirstSec: blobu
- Section: blobu LastSec: sectionv
- Section: sectionv
# Segment22: |-Sec-| # Segment22: |-Sec-|
# Segment23: |--|-Sec-| # Segment23: |--|-Sec-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x402C VAddr: 0x402C
Sections: FirstSec: sectionu
- Section: sectionu LastSec: sectionu
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x402E VAddr: 0x402E
Offset: 0x402E Offset: 0x402E
Sections: FirstSec: sectiont
- Section: sectiont LastSec: sectiont
# Segment24: |-unlabelled-|--| # Segment24: |-unlabelled-|--|
# Segment25: |--Sec--| # Segment25: |--Sec--|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4034 VAddr: 0x4034
FileSize: 6 FileSize: 6
Sections: FirstSec: blobt
- Section: blobt LastSec: blobt
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x4038 VAddr: 0x4038
Sections: FirstSec: sections
- Section: sections LastSec: sections
# The next batch of segments represent groups of three nested/overlapping segments, # The next batch of segments represent groups of three nested/overlapping segments,
# with one parent segment containing two overlapping segments. # with one parent segment containing two overlapping segments.
# Segment26: |-unlabelled-|-Sec-|-unlabelled-| # Segment26: |-unlabelled-|-Sec-|-unlabelled-|
# Segment27: |------------|--| # Segment27: |------------|--|
# Segment28: |-Sec-|------------| # Segment28: |-Sec-|------------|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5000 VAddr: 0x5000
Align: 0x1000 Align: 0x1000
Sections: FirstSec: bloba
- Section: bloba LastSec: blobb
- Section: sectiona
- Section: blobb
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5000 VAddr: 0x5000
FileSize: 6 FileSize: 6
Sections: FirstSec: bloba
- Section: bloba LastSec: bloba
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5004 VAddr: 0x5004
Sections: FirstSec: sectiona
- Section: sectiona LastSec: blobb
- Section: blobb
# Segment29: |-Sec-|-unlabelled-|-Sec-| # Segment29: |-Sec-|-unlabelled-|-Sec-|
# Segment30: |-Sec-|--------| # Segment30: |-Sec-|--------|
# Segment31: |---------|-Sec-| # Segment31: |---------|-Sec-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x500C VAddr: 0x500C
Sections: FirstSec: sectionb
- Section: sectionb LastSec: sectionc
- Section: blobc
- Section: sectionc
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x500C VAddr: 0x500C
FileSize: 7 FileSize: 7
Sections: FirstSec: sectionb
- Section: sectionb LastSec: sectionb
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5011 VAddr: 0x5011
Offset: 0x5011 Offset: 0x5011
Sections: FirstSec: sectionc
- Section: sectionc LastSec: sectionc
# Segment32: |-Sec-|-unlabelled-|-Sec-| # Segment32: |-Sec-|-unlabelled-|-Sec-|
# Segment33: |-Sec-|------------| # Segment33: |-Sec-|------------|
# Segment34: |------------|-Sec-| # Segment34: |------------|-Sec-|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5018 VAddr: 0x5018
Sections: FirstSec: sectiond
- Section: sectiond LastSec: sectione
- Section: blobd
- Section: sectione
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5018 VAddr: 0x5018
Sections: FirstSec: sectiond
- Section: sectiond LastSec: blobd
- Section: blobd
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x501C VAddr: 0x501C
Sections: FirstSec: blobd
- Section: blobd LastSec: sectione
- Section: sectione
# Segment35: |-unlabelled-|-Sec-|-unlabelled-| # Segment35: |-unlabelled-|-Sec-|-unlabelled-|
# Segment36: |------------|-Sec-| # Segment36: |------------|-Sec-|
# Segment37: |-Sec-|------------| # Segment37: |-Sec-|------------|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5024 VAddr: 0x5024
Sections: FirstSec: blobe
- Section: blobe LastSec: blobf
- Section: sectionf
- Section: blobf
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5024 VAddr: 0x5024
Sections: FirstSec: blobe
- Section: blobe LastSec: sectionf
- Section: sectionf
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5028 VAddr: 0x5028
Sections: FirstSec: sectionf
- Section: sectionf LastSec: blobf
- Section: blobf
# Segment38: |-unlabelled-|-Sec-|-unlabelled-| # Segment38: |-unlabelled-|-Sec-|-unlabelled-|
# Segment39: |------------|---| # Segment39: |------------|---|
# Segment40: |---|------------| # Segment40: |---|------------|
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5030 VAddr: 0x5030
Sections: FirstSec: blobg
- Section: blobg LastSec: blobh
- Section: sectiong
- Section: blobh
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5030 VAddr: 0x5030
FileSize: 7 FileSize: 7
Sections: FirstSec: blobg
- Section: blobg LastSec: blobg
- Type: 0x6ABCDEF0 - Type: 0x6ABCDEF0
VAddr: 0x5035 VAddr: 0x5035
Offset: 0x5035 Offset: 0x5035
Sections: FirstSec: blobh
- Section: blobh LastSec: blobh

llvm/test/tools/llvm-objcopy/ELF/program-headers.test

Show All 22 Lines - Name: .init
AddressAlign: 0x0000000000000010 AddressAlign: 0x0000000000000010
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: "00000000" Content: "00000000"
Address: 0xAAAA2000 Address: 0xAAAA2000
AddressAlign: 0x0000000000001000 AddressAlign: 0x0000000000001000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xAAAA1000 VAddr: 0xAAAA1000
PAddr: 0xFFFF1000 PAddr: 0xFFFF1000
Sections: FirstSec: .text
- Section: .text LastSec: .init
- Section: .init
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0xAAAA2000 VAddr: 0xAAAA2000
PAddr: 0xFFFF2000 PAddr: 0xFFFF2000
Sections: FirstSec: .data
- Section: .data LastSec: .data
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD #CHECK-NEXT: Type: PT_LOAD
#CHECK-NEXT: Offset: 0x1000 #CHECK-NEXT: Offset: 0x1000
#CHECK-NEXT: VirtualAddress: 0xAAAA1000 #CHECK-NEXT: VirtualAddress: 0xAAAA1000
#CHECK-NEXT: PhysicalAddress: 0xFFFF1000 #CHECK-NEXT: PhysicalAddress: 0xFFFF1000
#CHECK-NEXT: FileSize: 20 #CHECK-NEXT: FileSize: 20
Show All 20 Lines

llvm/test/tools/llvm-objcopy/ELF/remove-section-in-segment.test

Show All 36 Lines - Name: shf_alloc
Content: '11223344' Content: '11223344'
- Name: non_alloc - Name: non_alloc
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [] Flags: []
Content: '55667788' Content: '55667788'
ProgramHeaders: ProgramHeaders:
# Use an arbitrary segment type to show that the segment type is unimportant. # Use an arbitrary segment type to show that the segment type is unimportant.
- Type: 0x61234567 - Type: 0x61234567
Sections: FirstSec: shf_alloc
- Section: shf_alloc LastSec: non_alloc
- Section: non_alloc

llvm/test/tools/llvm-objcopy/ELF/segment-shift-section-remove.test

Show All 22 Lines - Name: .text2
Size: 0x1000 Size: 0x1000
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text3
## TODO (grimar): without the following line (i.e. without an empty symbol table), ## TODO (grimar): without the following line (i.e. without an empty symbol table),
## llvm-objcopy adds an empty .strtab section. It doesn't look correct. ## llvm-objcopy adds an empty .strtab section. It doesn't look correct.
Symbols: [] Symbols: []
#CHECK: SectionHeaderCount: 4 #CHECK: SectionHeaderCount: 4
# CHECK: Sections [ # CHECK: Sections [
# CHECK-NEXT: Section { # CHECK-NEXT: Section {
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/segment-shift.test

Show All 22 Lines - Name: .text2
Size: 0x1000 Size: 0x1000
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text3
# CHECK: ProgramHeaders [ # CHECK: ProgramHeaders [
# CHECK-NEXT: ProgramHeader { # CHECK-NEXT: ProgramHeader {
# CHECK-NEXT: Type: PT_LOAD (0x1) # CHECK-NEXT: Type: PT_LOAD (0x1)
# CHECK-NEXT: Offset: 0x1000 # CHECK-NEXT: Offset: 0x1000
# CHECK-NEXT: VirtualAddress: 0x1000 # CHECK-NEXT: VirtualAddress: 0x1000
# CHECK-NEXT: PhysicalAddress: 0x1000 # CHECK-NEXT: PhysicalAddress: 0x1000
# CHECK-NEXT: FileSize: 4096 # CHECK-NEXT: FileSize: 4096
Show All 20 Lines

llvm/test/tools/llvm-objcopy/ELF/segment-test-remove-section.test

Show All 30 Lines - Name: .text2
Content: "DEADBEEF" Content: "DEADBEEF"
- Name: .text3 - Name: .text3
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x3000 Address: 0x3000
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text3
- Section: .text2
- Section: .text3
## TODO (grimar): without the following line (i.e. without an empty symbol table), ## TODO (grimar): without the following line (i.e. without an empty symbol table),
## llvm-objcopy adds an empty .strtab section. It doesn't look correct. ## llvm-objcopy adds an empty .strtab section. It doesn't look correct.
Symbols: [] Symbols: []
# Make sure that when we remove a section we overwrite it with zeros # Make sure that when we remove a section we overwrite it with zeros
# DATA: {{^[^[:blank:]]+}} 00 00 00 00 # DATA: {{^[^[:blank:]]+}} 00 00 00 00
#CHECK: SectionHeaderCount: 4 #CHECK: SectionHeaderCount: 4
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/strip-all-gnu.test

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 LinesSections:
- Name: .rel.text - Name: .rel.text
Type: SHT_REL Type: SHT_REL
Info: .text Info: .text
- Name: .rela.text - Name: .rela.text
Type: SHT_RELA Type: SHT_RELA
Info: .text Info: .text
ProgramHeaders: ProgramHeaders:
# Use an arbitrary segment type to show that the segment type is unimportant. # Use an arbitrary segment type to show that the segment type is unimportant.
- Type: 0x61234567 - Type: 0x61234567
Sections: FirstSec: .debug_in_segment
- Section: .debug_in_segment LastSec: .debug_in_segment
# CHECK: SectionHeaderCount: 8 # CHECK: SectionHeaderCount: 8
# CHECK: Name: .dynstr # CHECK: Name: .dynstr
# CHECK: Name: .symtab.dyn # CHECK: Name: .symtab.dyn
# CHECK: Name: .text # CHECK: Name: .text
# CHECK: Name: .debug_loc # CHECK: Name: .debug_loc
# CHECK: Name: .comment # CHECK: Name: .comment
# CHECK: Name: .random_section_name # CHECK: Name: .random_section_name
# CHECK: Name: .shstrtab # CHECK: Name: .shstrtab
# COPY-BYTES: de ad be ef # COPY-BYTES: de ad be ef
# STRIP-BYTES: 00 00 00 00 # STRIP-BYTES: 00 00 00 00

llvm/test/tools/llvm-objcopy/ELF/strip-all.test

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines - Name: .text
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
- Name: .blarg - Name: .blarg
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ ] Flags: [ ]
- Name: .gnu.warning.foo - Name: .gnu.warning.foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
ProgramHeaders: ProgramHeaders:
# Use an arbitrary segment type to show that the segment type is unimportant. # Use an arbitrary segment type to show that the segment type is unimportant.
- Type: 0x61234567 - Type: 0x61234567
Sections: FirstSec: non_alloc_in_segment
- Section: non_alloc_in_segment LastSec: non_alloc_in_segment
# CHECK: SectionHeaderCount: 6 # CHECK: SectionHeaderCount: 6
# CHECK: Name: non_alloc_in_segment # CHECK: Name: non_alloc_in_segment
# CHECK: Name: .bss # CHECK: Name: .bss
# CHECK: Name: .text # CHECK: Name: .text
# CHECK: Name: .gnu.warning.foo # CHECK: Name: .gnu.warning.foo
# CHECK: Name: .shstrtab # CHECK: Name: .shstrtab

llvm/test/tools/llvm-objcopy/ELF/strip-non-alloc.test

Show All 21 LinesSections:
- Name: .bss - Name: .bss
Type: SHT_NOBITS Type: SHT_NOBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
ProgramHeaders: ProgramHeaders:
# Use an arbitrary segment type to show that the segment type is unimportant. # Use an arbitrary segment type to show that the segment type is unimportant.
- Type: 0x61234567 - Type: 0x61234567
Sections: FirstSec: non_alloc_in_segment
- Section: non_alloc_in_segment LastSec: non_alloc_in_segment
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: llvm-objcopy --strip-non-alloc %t2 %t2.out # RUN: llvm-objcopy --strip-non-alloc %t2 %t2.out
# RUN: llvm-readobj --file-headers --sections %t2.out | FileCheck --check-prefix=CHECK2 %s # RUN: llvm-readobj --file-headers --sections %t2.out | FileCheck --check-prefix=CHECK2 %s
# CHECK2: SectionHeaderCount: 3 # CHECK2: SectionHeaderCount: 3
# CHECK2: Name: .text # CHECK2: Name: .text
# CHECK2: Name: .shstrtab # CHECK2: Name: .shstrtab
Show All 11 Lines
## empty_trailing_non_alloc is considered included by the segment, ## empty_trailing_non_alloc is considered included by the segment,
## so it will be retained. ## so it will be retained.
- Name: empty_trailing_non_alloc - Name: empty_trailing_non_alloc
Type: SHT_PROGBITS Type: SHT_PROGBITS
- Name: trailing_non_alloc - Name: trailing_non_alloc
Type: SHT_PROGBITS Type: SHT_PROGBITS
Content: 00 Content: 00
ProgramHeaders: ProgramHeaders:
- Type: 0x61234567 - Type: 0x61234567
Sections: FirstSec: .text
- Section: .text LastSec: .text

llvm/test/tools/llvm-objcopy/ELF/strip-sections.test

Show All 28 Lines - Name: .non_alloc_in_segment
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ ] Flags: [ ]
Content: "CAFEBABE" Content: "CAFEBABE"
- Name: .non_alloc_not_in_segment - Name: .non_alloc_not_in_segment
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ ] Flags: [ ]
Content: "FEEDFACE" Content: "FEEDFACE"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .non_alloc_in_segment
- Section: .non_alloc_in_segment
# DATA: {{^[^[:blank:]]+}} de ad be ef ca fe ba be # DATA: {{^[^[:blank:]]+}} de ad be ef ca fe ba be
# DATA-NOT: fe ed fa ce # DATA-NOT: fe ed fa ce
# VALIDATE: {{^[^[:blank:]]+}} de ad be ef ca fe ba be fe ed fa ce # VALIDATE: {{^[^[:blank:]]+}} de ad be ef ca fe ba be fe ed fa ce
# CHECK: ElfHeader { # CHECK: ElfHeader {
# CHECK-NEXT: Ident { # CHECK-NEXT: Ident {
Show All 39 Lines

llvm/test/tools/llvm-objcopy/ELF/triple-overlap.test

Show All 34 Lines - Name: .text4
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
- Name: .text5 - Name: .text5
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x1000 AddressAlign: 0x1000
Size: 4096 Size: 4096
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text4
- Section: .text4 LastSec: .text5
- Section: .text5
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text5
- Section: .text4
- Section: .text5
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text5
- Section: .text2
- Section: .text3
- Section: .text4
- Section: .text5
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text2
- Section: .text2 LastSec: .text5
- Section: .text3
- Section: .text4
- Section: .text5
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD (0x1) #CHECK-NEXT: Type: PT_LOAD (0x1)
#CHECK-NEXT: Offset: 0x4000 #CHECK-NEXT: Offset: 0x4000
#CHECK-NEXT: VirtualAddress: 0x0 #CHECK-NEXT: VirtualAddress: 0x0
#CHECK-NEXT: PhysicalAddress: 0x0 #CHECK-NEXT: PhysicalAddress: 0x0
#CHECK-NEXT: FileSize: 8192 #CHECK-NEXT: FileSize: 8192
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-end.test

Show All 33 LinesSections:
- Name: .text4 - Name: .text4
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x4000 Address: 0x4000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "FFFFFFFF" Content: "FFFFFFFF"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text4
- Section: .text4
# CHECK: 000000 c3 c3 c3 c3 # CHECK: 000000 c3 c3 c3 c3
# CHECK: 001000 de ad be ef # CHECK: 001000 de ad be ef
# CHECK: 002000 32 32 32 32 # CHECK: 002000 32 32 32 32
# SIZE: 12288 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-first.test

Show All 33 LinesSections:
- Name: .text4 - Name: .text4
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x4000 Address: 0x4000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "FFFFFFFF" Content: "FFFFFFFF"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text4
- Section: .text4
# CHECK: 000000 de ad be ef # CHECK: 000000 de ad be ef
# CHECK: 001000 32 32 32 32 # CHECK: 001000 32 32 32 32
# CHECK: 002000 ff ff ff ff # CHECK: 002000 ff ff ff ff
# SIZE: 12288 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-third-sec.test

Show All 33 LinesSections:
- Name: .text4 - Name: .text4
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x4000 Address: 0x4000
AddressAlign: 0x1000 AddressAlign: 0x1000
Content: "FFFFFFFF" Content: "FFFFFFFF"
Size: 0x1000 Size: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .text3
- Section: .text3 LastSec: .text4
- Section: .text4
# CHECK: 000000 c3 c3 c3 c3 # CHECK: 000000 c3 c3 c3 c3
# CHECK: 001000 de ad be ef # CHECK: 001000 de ad be ef
# CHECK: 002000 00 00 00 00 # CHECK: 002000 00 00 00 00
# CHECK: 003000 ff ff ff ff # CHECK: 003000 ff ff ff ff
# SIZE: 16384 # SIZE: 16384

llvm/test/tools/llvm-objdump/ELF/dynamic-section-machine-specific.test

Show All 22 Lines Entries:
Value: 0x10 Value: 0x10
- Tag: DT_HEXAGON_VER - Tag: DT_HEXAGON_VER
Value: 0x1000 Value: 0x1000
- Tag: DT_HEXAGON_PLT - Tag: DT_HEXAGON_PLT
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 2: Test that MIPS machine-specific tags can be dumped. ## Case 2: Test that MIPS machine-specific tags can be dumped.
## MIPS has a few long tag names. Show that we indent columns properly. ## MIPS has a few long tag names. Show that we indent columns properly.
# RUN: yaml2obj --docnum=2 -o %t.mips %s # RUN: yaml2obj --docnum=2 -o %t.mips %s
# RUN: llvm-objdump -p %t.mips | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=MIPS # RUN: llvm-objdump -p %t.mips | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=MIPS
# MIPS:Dynamic Section: # MIPS:Dynamic Section:
# MIPS-NEXT: MIPS_RLD_VERSION 0x0000000012345678 # MIPS-NEXT: MIPS_RLD_VERSION 0x0000000012345678
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines Entries:
Value: 0x1000 Value: 0x1000
- Tag: DT_MIPS_RWPLT - Tag: DT_MIPS_RWPLT
Value: 0x1000 Value: 0x1000
- Tag: DT_MIPS_RLD_MAP_REL - Tag: DT_MIPS_RLD_MAP_REL
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 3: Test that PPC machine-specific tags can be dumped. ## Case 3: Test that PPC machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=3 -o %t.ppc %s # RUN: yaml2obj --docnum=3 -o %t.ppc %s
# RUN: llvm-objdump -p %t.ppc | FileCheck %s --check-prefix=PPC # RUN: llvm-objdump -p %t.ppc | FileCheck %s --check-prefix=PPC
# PPC: Dynamic Section: # PPC: Dynamic Section:
# PPC-NEXT: PPC_GOT 0x000200c0 # PPC-NEXT: PPC_GOT 0x000200c0
# PPC-NEXT: PPC_OPT 0x00000001 # PPC-NEXT: PPC_OPT 0x00000001
Show All 10 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_PPC_GOT - Tag: DT_PPC_GOT
Value: 0x200c0 Value: 0x200c0
- Tag: DT_PPC_OPT - Tag: DT_PPC_OPT
Value: 1 Value: 1
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 4: Test that PPC64 machine-specific tags can be dumped. ## Case 4: Test that PPC64 machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=4 -o %t.ppc64 %s # RUN: yaml2obj --docnum=4 -o %t.ppc64 %s
# RUN: llvm-objdump -p %t.ppc64 | FileCheck %s --check-prefix=PPC64 # RUN: llvm-objdump -p %t.ppc64 | FileCheck %s --check-prefix=PPC64
# PPC64: Dynamic Section: # PPC64: Dynamic Section:
# PPC64-NEXT: PPC64_GLINK 0x0000000000001000 # PPC64-NEXT: PPC64_GLINK 0x0000000000001000
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Machine: EM_PPC64 Machine: EM_PPC64
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Entries: Entries:
- Tag: DT_PPC64_GLINK - Tag: DT_PPC64_GLINK
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 5: Test that AARCH64 machine-specific tags can be dumped. ## Case 5: Test that AARCH64 machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=5 -o %t.aarch64 %s # RUN: yaml2obj --docnum=5 -o %t.aarch64 %s
# RUN: llvm-objdump -p %t.aarch64 | FileCheck %s --check-prefix=AARCH64 # RUN: llvm-objdump -p %t.aarch64 | FileCheck %s --check-prefix=AARCH64
# AARCH64: Dynamic Section: # AARCH64: Dynamic Section:
# AARCH64-NEXT: AARCH64_BTI_PLT 0x0000000000000001 # AARCH64-NEXT: AARCH64_BTI_PLT 0x0000000000000001
# AARCH64-NEXT: AARCH64_PAC_PLT 0x0000000000000002 # AARCH64-NEXT: AARCH64_PAC_PLT 0x0000000000000002
Show All 10 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_AARCH64_BTI_PLT - Tag: DT_AARCH64_BTI_PLT
Value: 1 Value: 1
- Tag: DT_AARCH64_PAC_PLT - Tag: DT_AARCH64_PAC_PLT
Value: 2 Value: 2
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-objdump/ELF/dynamic-section.test

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines## An OS specific tag.
- Tag: 0x6abcdef0 - Tag: 0x6abcdef0
Value: 0x9988776655443322 Value: 0x9988776655443322
## A processor specific tags. ## A processor specific tags.
- Tag: 0x76543210 - Tag: 0x76543210
Value: 0x5555666677778888 Value: 0x5555666677778888
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1010 VAddr: 0x1010
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: llvm-objdump -p %t2 | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=ELF32 # RUN: llvm-objdump -p %t2 | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=ELF32
# ELF32:Dynamic Section: # ELF32:Dynamic Section:
# ELF32-NEXT: NEEDED D # ELF32-NEXT: NEEDED D
# ELF32-NEXT: PLTRELSZ 0x00000010 # ELF32-NEXT: PLTRELSZ 0x00000010
# ELF32-NEXT: PLTGOT 0x00001000 # ELF32-NEXT: PLTGOT 0x00001000
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines## An OS specific tag.
- Tag: 0x6abcdef0 - Tag: 0x6abcdef0
Value: 0x99887766 Value: 0x99887766
## A processor specific tags. ## A processor specific tags.
- Tag: 0x76543210 - Tag: 0x76543210
Value: 0x55556666 Value: 0x55556666
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1010 VAddr: 0x1010
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## When printing the value column we want to have the minimal possible indentation. ## When printing the value column we want to have the minimal possible indentation.
## Use an arbitrary dynamic tag to demonstrate that. ## Use an arbitrary dynamic tag to demonstrate that.
# RUN: yaml2obj --docnum=3 %s -o %t3 # RUN: yaml2obj --docnum=3 %s -o %t3
# RUN: llvm-objdump -p %t3 | FileCheck %s --strict-whitespace --check-prefix=INDENT # RUN: llvm-objdump -p %t3 | FileCheck %s --strict-whitespace --check-prefix=INDENT
# RUN: yaml2obj --docnum=4 %s -o %t4 # RUN: yaml2obj --docnum=4 %s -o %t4
Show All 34 Lines

llvm/test/tools/llvm-objdump/X86/elf-disassemble-dynamic-symbols.test

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 LinesFileHeader:
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR] Flags: [SHF_ALLOC, SHF_EXECINSTR]
Address: 0x1000 Address: 0x1000
Content: 909090909090909090909090 Content: 909090909090909090909090
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
Symbols: Symbols:
- Name: both_static - Name: both_static
Value: 0x1001 Value: 0x1001
Section: .text Section: .text
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: only_static - Name: only_static
Value: 0x1002 Value: 0x1002
Section: .text Section: .text
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objdump/X86/elf-dynamic-relocs.test

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines Entries:
- Tag: DT_RELENT - Tag: DT_RELENT
Value: 16 Value: 16
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x100000 VAddr: 0x100000
Align: 0x100 Align: 0x100
Sections: FirstSec: .foo
- Section: .foo LastSec: .dynamic
- Section: .rela.dyn
jhendersonUnsubmitted
Done
ReplyInline Actions

Side-note: this one was previously missing .got.plt!

jhenderson: Side-note: this one was previously missing .got.plt!
- Section: .rela.plt
- Section: .rel.dyn
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x100500 VAddr: 0x100500
Align: 0x100 Align: 0x100
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
Section: .foo Section: .foo
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: bar - Name: bar
Type: STT_FUNC Type: STT_FUNC
Binding: STB_GLOBAL Binding: STB_GLOBAL

llvm/test/tools/llvm-objdump/X86/phdrs-lma.test

Show All 27 Lines - Name: .init
Content: "00000000" Content: "00000000"
Address: 0x00001010 Address: 0x00001010
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: "00000000" Content: "00000000"
Address: 0x00002000 Address: 0x00002000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x00001000 VAddr: 0x00001000
PAddr: 0x00002000 PAddr: 0x00002000
Sections: FirstSec: .text
- Section: .text LastSec: .init
- Section: .init
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x00002000 VAddr: 0x00002000
PAddr: 0x00003000 PAddr: 0x00003000
Sections: FirstSec: .data
- Section: .data LastSec: .data

llvm/test/tools/llvm-objdump/X86/phdrs-lma2.test

Show All 39 Lines - Name: .init
Content: "00000000" Content: "00000000"
Address: 0x00001010 Address: 0x00001010
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: "00000000" Content: "00000000"
Address: 0x00002000 Address: 0x00002000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x00001000 VAddr: 0x00001000
Sections: FirstSec: .text
- Section: .text LastSec: .init
- Section: .init
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x00002000 VAddr: 0x00002000
Sections: FirstSec: .data
- Section: .data LastSec: .data

llvm/test/tools/llvm-objdump/section-filter.test

Show All 34 Lines - Name: .data
Content: '42' Content: '42'
- Name: .bss - Name: .bss
Type: SHT_NOBITS Type: SHT_NOBITS
Flags: [SHF_ALLOC, SHF_WRITE] Flags: [SHF_ALLOC, SHF_WRITE]
Address: 0x420 Address: 0x420
AddressAlign: 0x10 AddressAlign: 0x10
Size: 1 Size: 1
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x400 VAddr: 0x400
PAddr: 0x1000 PAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x410 VAddr: 0x410
PAddr: 0x2000 PAddr: 0x2000
Sections: FirstSec: .data
- Section: .data LastSec: .data
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x420 VAddr: 0x420
PAddr: 0x3000 PAddr: 0x3000
Sections: FirstSec: .bss
- Section: .bss LastSec: .bss
## Test that --section works with --fault-map-section. ## Test that --section works with --fault-map-section.
# RUN: yaml2obj %s --docnum=2 -o %t.o # RUN: yaml2obj %s --docnum=2 -o %t.o
# RUN: llvm-objdump %t.o --fault-map-section -j __clangast \ # RUN: llvm-objdump %t.o --fault-map-section -j __clangast \
# RUN: | FileCheck %s --check-prefixes=FAULTMAP,NO-FAULTMAP # RUN: | FileCheck %s --check-prefixes=FAULTMAP,NO-FAULTMAP
# RUN: llvm-objdump %t.o --fault-map-section -j .llvm_faultmaps \ # RUN: llvm-objdump %t.o --fault-map-section -j .llvm_faultmaps \
# RUN: | FileCheck %s --check-prefixes=FAULTMAP,WITH-FAULTMAP # RUN: | FileCheck %s --check-prefixes=FAULTMAP,WITH-FAULTMAP
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objdump/warn-on-out-of-range-start-stop-address.test

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Lines - Name: .text2
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x1400 Address: 0x1400
Size: 4 Size: 4
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
FileSize: 0x500 FileSize: 0x500
Sections: FirstSec: .text
- Section: .text LastSec: .text2
- Section: .text2
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x2000 Address: 0x2000
Size: 4 Size: 4
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
FileSize: 0x4 FileSize: 0x4
Sections: FirstSec: .text
- Section: .text LastSec: .text
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_REL Type: ET_REL
Machine: EM_X86_64 Machine: EM_X86_64
Sections: Sections:
Show All 16 Lines

llvm/test/tools/llvm-readobj/ELF/all.test

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines## An arbitrary linker-generated valid content.
Content: 1400000000000000017a5200017810011b0c070890010000100000001c000000c8efffff0100000000000000 Content: 1400000000000000017a5200017810011b0c070890010000100000001c000000c8efffff0100000000000000
- Name: .note.gnu.build-id - Name: .note.gnu.build-id
Type: SHT_NOTE Type: SHT_NOTE
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x1500 Address: 0x1500
## An arbitrary linker-generated valid content. ## An arbitrary linker-generated valid content.
Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .hash
- Section: .hash
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_GNU_EH_FRAME - Type: PT_GNU_EH_FRAME
Sections: FirstSec: .eh_frame_hdr
- Section: .eh_frame_hdr LastSec: .eh_frame_hdr
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.gnu.build-id
- Section: .note.gnu.build-id LastSec: .note.gnu.build-id
Symbols: [] Symbols: []
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo

llvm/test/tools/llvm-readobj/ELF/broken-dynamic-reloc.test

Show All 38 Lines Entries:
Value: 0x0000000000000018 Value: 0x0000000000000018
- Tag: DT_RELAENT - Tag: DT_RELAENT
Value: 0x0000000000000018 Value: 0x0000000000000018
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
DynamicSymbols: DynamicSymbols:
- StName: 0x1234 - StName: 0x1234
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynamic
- Section: .dynamic
## Show we print a warning for an invalid relocation table size stored in a DT_RELASZ entry. ## Show we print a warning for an invalid relocation table size stored in a DT_RELASZ entry.
# RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG1VAL=0xFF -DTAG2=DT_RELAENT %s -o %t2 # RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG1VAL=0xFF -DTAG2=DT_RELAENT %s -o %t2
# RUN: llvm-readobj --dyn-relocations %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=INVALID-DT-RELASZ # RUN: llvm-readobj --dyn-relocations %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=INVALID-DT-RELASZ
# RUN: llvm-readelf --dyn-relocations %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=INVALID-DT-RELASZ # RUN: llvm-readelf --dyn-relocations %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=INVALID-DT-RELASZ
# INVALID-DT-RELASZ: warning: '[[FILE]]': invalid DT_RELASZ value (0xff) or DT_RELAENT value (0x18) # INVALID-DT-RELASZ: warning: '[[FILE]]': invalid DT_RELASZ value (0xff) or DT_RELAENT value (0x18)
Show All 13 Lines Entries:
- Tag: [[TAG1]] - Tag: [[TAG1]]
Value: [[TAG1VAL=0x18]] Value: [[TAG1VAL=0x18]]
- Tag: [[TAG2]] - Tag: [[TAG2]]
Value: [[TAG2VAL=0x18]] Value: [[TAG2VAL=0x18]]
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .relx.dyn
- Section: .relx.dyn LastSec: .dynamic
- Section: .dynamic
## Show we print a warning for an invalid relocation table entry size stored in a DT_RELAENT entry. ## Show we print a warning for an invalid relocation table entry size stored in a DT_RELAENT entry.
# RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG2=DT_RELAENT -DTAG2VAL=0xFF %s -o %t3 # RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG2=DT_RELAENT -DTAG2VAL=0xFF %s -o %t3
# RUN: llvm-readobj --dyn-relocations %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=INVALID-DT-RELAENT # RUN: llvm-readobj --dyn-relocations %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=INVALID-DT-RELAENT
# RUN: llvm-readelf --dyn-relocations %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=INVALID-DT-RELAENT # RUN: llvm-readelf --dyn-relocations %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=INVALID-DT-RELAENT
## INVALID-DT-RELAENT: warning: '[[FILE]]': invalid DT_RELASZ value (0x18) or DT_RELAENT value (0xff) ## INVALID-DT-RELAENT: warning: '[[FILE]]': invalid DT_RELASZ value (0x18) or DT_RELAENT value (0xff)
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines Entries:
- Tag: DT_PLTRELSZ - Tag: DT_PLTRELSZ
Value: 0xFF ## The valid value would be 0x18. Value: 0xFF ## The valid value would be 0x18.
- Tag: DT_PLTREL - Tag: DT_PLTREL
Value: 0x7 ## DT_RELA Value: 0x7 ## DT_RELA
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.plt
- Section: .rela.plt LastSec: .dynamic
- Section: .dynamic
## Show we print a warning when dumping dynamic relocations if there is no dynamic symbol table. ## Show we print a warning when dumping dynamic relocations if there is no dynamic symbol table.
# RUN: yaml2obj --docnum=4 %s -o %t11 # RUN: yaml2obj --docnum=4 %s -o %t11
# RUN: llvm-readobj --dyn-relocations %t11 2>&1 | FileCheck %s -DFILE=%t11 --check-prefix=LLVM-NO-DYNSYM # RUN: llvm-readobj --dyn-relocations %t11 2>&1 | FileCheck %s -DFILE=%t11 --check-prefix=LLVM-NO-DYNSYM
# RUN: llvm-readelf --dyn-relocations %t11 2>&1 | FileCheck %s -DFILE=%t11 --check-prefix=GNU-NO-DYNSYM # RUN: llvm-readelf --dyn-relocations %t11 2>&1 | FileCheck %s -DFILE=%t11 --check-prefix=GNU-NO-DYNSYM
# LLVM-NO-DYNSYM: Dynamic Relocations { # LLVM-NO-DYNSYM: Dynamic Relocations {
# LLVM-NO-DYNSYM-NEXT: warning: '[[FILE]]': unable to get name of the dynamic symbol with index 0: no dynamic symbol table found # LLVM-NO-DYNSYM-NEXT: warning: '[[FILE]]': unable to get name of the dynamic symbol with index 0: no dynamic symbol table found
Show All 29 Lines Entries:
Value: 0x0 Value: 0x0
- Tag: DT_RELASZ - Tag: DT_RELASZ
Value: 0x30 Value: 0x30
- Tag: DT_RELAENT - Tag: DT_RELAENT
Value: 0x18 Value: 0x18
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynamic
- Section: .dynamic
## Show we print a warning when the symbol index of a dynamic relocation is too ## Show we print a warning when the symbol index of a dynamic relocation is too
## large (goes past the end of the dynamic symbol table). ## large (goes past the end of the dynamic symbol table).
# RUN: yaml2obj --docnum=5 %s -o %t12 # RUN: yaml2obj --docnum=5 %s -o %t12
# RUN: llvm-readobj --dyn-relocations %t12 2>&1 | FileCheck %s -DFILE=%t12 --check-prefix=LLVM-INVALID-DYNSYM # RUN: llvm-readobj --dyn-relocations %t12 2>&1 | FileCheck %s -DFILE=%t12 --check-prefix=LLVM-INVALID-DYNSYM
# RUN: llvm-readelf --dyn-relocations %t12 2>&1 | FileCheck %s -DFILE=%t12 --check-prefix=GNU-INVALID-DYNSYM # RUN: llvm-readelf --dyn-relocations %t12 2>&1 | FileCheck %s -DFILE=%t12 --check-prefix=GNU-INVALID-DYNSYM
# LLVM-INVALID-DYNSYM: Dynamic Relocations { # LLVM-INVALID-DYNSYM: Dynamic Relocations {
Show All 27 Lines Entries:
Value: 0x18 Value: 0x18
- Tag: DT_RELAENT - Tag: DT_RELAENT
Value: 0x18 Value: 0x18
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynamic
- Section: .dynamic
## Show that when we have both REL and RELA relocations, we dump both sets. ## Show that when we have both REL and RELA relocations, we dump both sets.
# RUN: yaml2obj --docnum=6 %s -o %t13 # RUN: yaml2obj --docnum=6 %s -o %t13
# RUN: llvm-readobj --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-LLVM # RUN: llvm-readobj --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-LLVM
# RUN: llvm-readelf --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-GNU # RUN: llvm-readelf --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-GNU
# BOTH-RELA-REL-LLVM: Dynamic Relocations { # BOTH-RELA-REL-LLVM: Dynamic Relocations {
# BOTH-RELA-REL-LLVM-NEXT: 0x1 R_X86_64_NONE - 0x0 # BOTH-RELA-REL-LLVM-NEXT: 0x1 R_X86_64_NONE - 0x0
Show All 40 Lines## 0x18 == offset of .rel.dyn == size of .rela.dyn section.
- Tag: DT_RELSZ - Tag: DT_RELSZ
Value: 0x10 Value: 0x10
- Tag: DT_RELENT - Tag: DT_RELENT
Value: 0x10 Value: 0x10
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynamic
- Section: .rel.dyn
- Section: .dynamic
## Check that llvm-readobj/llvm-readelf reports a warning when dumping a relocation ## Check that llvm-readobj/llvm-readelf reports a warning when dumping a relocation
## which refers to a symbol past the end of the file. ## which refers to a symbol past the end of the file.
# RUN: yaml2obj --docnum=7 %s -o %t7 # RUN: yaml2obj --docnum=7 %s -o %t7
# RUN: llvm-readobj --dyn-relocations %t7 2>&1 | \ # RUN: llvm-readobj --dyn-relocations %t7 2>&1 | \
# RUN: FileCheck %s -DFILE=%t7 --check-prefix=PAST-EOF-LLVM # RUN: FileCheck %s -DFILE=%t7 --check-prefix=PAST-EOF-LLVM
# RUN: llvm-readelf --dyn-relocations %t7 2>&1 | \ # RUN: llvm-readelf --dyn-relocations %t7 2>&1 | \
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines## last in the file. This makes the task of validating offsets a bit easier.
- Name: .dynsym - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x300 Address: 0x300
Offset: 0x300 Offset: 0x300
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Offset: 0x0 Offset: 0x0
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynsym
- Section: .rela.dyn
- Section: .dynsym
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
SectionHeaderTable: SectionHeaderTable:
NoHeaders: true NoHeaders: true

llvm/test/tools/llvm-readobj/ELF/check-output-order.test

Show All 34 Lines
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Entries: Entries:
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/demangle.test

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 LinesSymbols:
- Name: _Z4blahf - Name: _Z4blahf
Type: STT_FUNC Type: STT_FUNC
Section: .text.foo Section: .text.foo
Binding: STB_GLOBAL Binding: STB_GLOBAL
DynamicSymbols: DynamicSymbols:
- Name: _Z3fooi - Name: _Z3fooi
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
VAddr: 0x0 VAddr: 0x0
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .text.foo
- Section: .dynsym
- Section: .rela.dyn
- Section: .dynamic
- Section: .text.foo
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/dyn-symbols-size-from-hash-table.test

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines - Name: foo
Type: STT_FUNC Type: STT_FUNC
Section: .text Section: .text
Value: 0x100 Value: 0x100
- Name: bar - Name: bar
Type: STT_OBJECT Type: STT_OBJECT
Section: .data Section: .data
Value: 0x200 Value: 0x200
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0 VAddr: 0
Sections: FirstSec: .text
- Section: .text LastSec: .data
- Section: .data
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x400 VAddr: 0x400
Sections: FirstSec: .dynsym
- Section: .dynsym LastSec: .dynamic
- Section: .hash
- Section: .dynstr
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0xA00 VAddr: 0xA00
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 2: Table size from DT_HASH does not match size from section header. ## Case 2: Table size from DT_HASH does not match size from section header.
# RUN: yaml2obj --docnum=2 %s -o %t2-smaller -DCHAIN="[1, 2]" # RUN: yaml2obj --docnum=2 %s -o %t2-smaller -DCHAIN="[1, 2]"
# RUN: llvm-readobj --dyn-symbols %t2-smaller 2>&1 | \ # RUN: llvm-readobj --dyn-symbols %t2-smaller 2>&1 | \
# RUN: FileCheck %s --check-prefixes=LLVM2,WARN \ # RUN: FileCheck %s --check-prefixes=LLVM2,WARN \
# RUN: --implicit-check-not=warning: -DNCHAIN=2 # RUN: --implicit-check-not=warning: -DNCHAIN=2
# RUN: llvm-readelf --dyn-symbols %t2-smaller 2>&1 | \ # RUN: llvm-readelf --dyn-symbols %t2-smaller 2>&1 | \
# RUN: FileCheck %s --check-prefixes=GNU2,WARN \ # RUN: FileCheck %s --check-prefixes=GNU2,WARN \
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines - Name: bar
Type: STT_OBJECT Type: STT_OBJECT
Section: .data Section: .data
Value: 0x200 Value: 0x200
- Name: baz - Name: baz
Type: STT_OBJECT Type: STT_OBJECT
Section: .data Section: .data
Value: 0x300 Value: 0x300
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0 VAddr: 0
Sections: FirstSec: .text
- Section: .text LastSec: .data
- Section: .data
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x400 VAddr: 0x400
Sections: FirstSec: .dynsym
- Section: .dynsym LastSec: .dynamic
- Section: .hash
- Section: .dynstr
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0xA00 VAddr: 0xA00
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 3: DT_HASH is missing. ## Case 3: DT_HASH is missing.
## Show that no warning occurs if there are section headers. ## Show that no warning occurs if there are section headers.
# RUN: yaml2obj --docnum=1 %s -o %t3 -DTAG1=DT_SYMTAB -DVAL1=0x400 -DTAG2=DT_NULL -DVAL2=0 -DBITS=64 # RUN: yaml2obj --docnum=1 %s -o %t3 -DTAG1=DT_SYMTAB -DVAL1=0x400 -DTAG2=DT_NULL -DVAL2=0 -DBITS=64
# RUN: llvm-readobj --dyn-symbols %t3 2>&1 | \ # RUN: llvm-readobj --dyn-symbols %t3 2>&1 | \
# RUN: FileCheck %s --check-prefixes=LLVM1,NOSTRIP --implicit-check-not=warning: # RUN: FileCheck %s --check-prefixes=LLVM1,NOSTRIP --implicit-check-not=warning:
# RUN: llvm-readelf --dyn-symbols %t3 2>&1 | \ # RUN: llvm-readelf --dyn-symbols %t3 2>&1 | \
# RUN: FileCheck %s --check-prefixes=GNU1,GNU1-NOSTRIP --implicit-check-not=warning: # RUN: FileCheck %s --check-prefixes=GNU1,GNU1-NOSTRIP --implicit-check-not=warning:
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines## 0x68 + PT_LOAD's p_offset (0x78) == .hash section offset (0xE0).
- Name: .hash - Name: .hash
Type: SHT_HASH Type: SHT_HASH
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Bucket: [ 0 ] Bucket: [ 0 ]
Chain: [ 0 ] Chain: [ 0 ]
NChain: 0xFFFFFFFF NChain: 0xFFFFFFFF
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.plt
- Section: .rela.plt LastSec: .hash
- Section: .dynamic
- Section: .hash
VAddr: 0x1000 VAddr: 0x1000

llvm/test/tools/llvm-readobj/ELF/dyn-symbols.test

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines Entries:
Value: 0 Value: 0
- Name: .dynsym - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
Address: 0x100 Address: 0x100
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
- Name: bar - Name: bar
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x100 VAddr: 0x100
Sections: FirstSec: .dynsym
- Section: .dynsym LastSec: .dynsym
## Case 2: Check the output for aliases. ## Case 2: Check the output for aliases.
## a) Check the two-letter alias --dt is equivalent to the --dyn-symbols ## a) Check the two-letter alias --dt is equivalent to the --dyn-symbols
## full flag name. ## full flag name.
# RUN: llvm-readobj --dt %t1.so > %t.readobj-dt-alias # RUN: llvm-readobj --dt %t1.so > %t.readobj-dt-alias
# RUN: llvm-readobj --dyn-symbols %t1.so > %t.readobj-dt-no-alias # RUN: llvm-readobj --dyn-symbols %t1.so > %t.readobj-dt-no-alias
# RUN: cmp %t.readobj-dt-alias %t.readobj-dt-no-alias # RUN: cmp %t.readobj-dt-alias %t.readobj-dt-no-alias
## b) Check --dyn-syms equals --dyn-symbols, --dt for llvm-readobj. ## b) Check --dyn-syms equals --dyn-symbols, --dt for llvm-readobj.
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_SYMTAB - Tag: DT_SYMTAB
Value: 0xffff1234 Value: 0xffff1234
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x0000 VAddr: 0x0000
Sections: FirstSec: .dynsym
- Section: .dynsym LastSec: .dynsym
## Case 6: Check that if we can get the location of the dynamic symbol table using both the DT_SYMTAB value ## Case 6: Check that if we can get the location of the dynamic symbol table using both the DT_SYMTAB value
## and the section headers table then we prefer the former and report a warning. ## and the section headers table then we prefer the former and report a warning.
# RUN: yaml2obj --docnum=5 %s -o %t5.so # RUN: yaml2obj --docnum=5 %s -o %t5.so
# RUN: llvm-readobj %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-LLVM # RUN: llvm-readobj %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-LLVM
# RUN: llvm-readelf %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-GNU # RUN: llvm-readelf %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-GNU
# PREFER-DTSYMTAB: warning: '[[FILE]]': SHT_DYNSYM section header and DT_SYMTAB disagree about the location of the dynamic symbol table # PREFER-DTSYMTAB: warning: '[[FILE]]': SHT_DYNSYM section header and DT_SYMTAB disagree about the location of the dynamic symbol table
Show All 17 Lines - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
- Name: .mydynsym - Name: .mydynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
## The Content describes 2 symbols: zero symbol and symbol with st_name == 3. ## The Content describes 2 symbols: zero symbol and symbol with st_name == 3.
Content: "000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000" Content: "000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000"
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x0000 VAddr: 0x0000
Sections: FirstSec: .mydynsym
- Section: .mydynsym LastSec: .mydynsym
## Case 7: Check how we dump versioned symbols. Use both -V and --dyn-symbols ## Case 7: Check how we dump versioned symbols. Use both -V and --dyn-symbols
## to check that printed version is consistent. ## to check that printed version is consistent.
# RUN: yaml2obj %s --docnum=6 -o %t6 # RUN: yaml2obj %s --docnum=6 -o %t6
# RUN: llvm-readobj -V --dyn-symbols %t6 | FileCheck %s --check-prefix=VERSIONED-LLVM # RUN: llvm-readobj -V --dyn-symbols %t6 | FileCheck %s --check-prefix=VERSIONED-LLVM
# RUN: llvm-readelf -V --dyn-symbols %t6 | FileCheck %s --check-prefix=VERSIONED-GNU # RUN: llvm-readelf -V --dyn-symbols %t6 | FileCheck %s --check-prefix=VERSIONED-GNU
# VERSIONED-LLVM: Symbol { # VERSIONED-LLVM: Symbol {
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines Entries:
Value: 0x100 Value: 0x100
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
- Name: .dynsym - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
Address: 0x100 Address: 0x100
Size: 0x1 Size: 0x1
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x100 VAddr: 0x100
Sections: FirstSec: .dynsym
- Section: .dynsym LastSec: .dynsym
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS[[BITS]] Class: ELFCLASS[[BITS]]
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
Sections: Sections:
- Name: .dynamic - Name: .dynamic
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines Entries:
Value: 0xffffffff Value: 0xffffffff
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- StName: 0xffffff00 - StName: 0xffffff00
## An arbitrary valid symbol to document we report an error before dumping it. ## An arbitrary valid symbol to document we report an error before dumping it.
- StName: 0x1 - StName: 0x1
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
## Case 11: check various warnings we report when fields of the SHT_DYNSYM section are broken. ## Case 11: check various warnings we report when fields of the SHT_DYNSYM section are broken.
## a) check we report a warning when the entry size of the dynamic symbol table is zero. ## a) check we report a warning when the entry size of the dynamic symbol table is zero.
# RUN: yaml2obj %s --docnum=14 -DENTSIZE=0x0 -o %t15.entsize # RUN: yaml2obj %s --docnum=14 -DENTSIZE=0x0 -o %t15.entsize
# RUN: llvm-readobj --dyn-symbols %t15.entsize 2>&1 | FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-LLVM # RUN: llvm-readobj --dyn-symbols %t15.entsize 2>&1 | FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-LLVM
# RUN: llvm-readelf --dyn-symbols %t15.entsize 2>&1 | \ # RUN: llvm-readelf --dyn-symbols %t15.entsize 2>&1 | \
# RUN: FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-GNU --implicit-check-not="Symbol table" # RUN: FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-GNU --implicit-check-not="Symbol table"
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/tools/llvm-readobj/ELF/dynamic-empty.test

Show All 12 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Address: 0x1000 Address: 0x1000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-malformed.test

Show All 29 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Address: 0x1000 Address: 0x1000
Content: "01234567" Content: "01234567"
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Test handling of a .dynamic section with an invalid entsize (i.e. not 2 * sizeof(Elf_Dyn)). ## Test handling of a .dynamic section with an invalid entsize (i.e. not 2 * sizeof(Elf_Dyn)).
# RUN: yaml2obj %s --docnum=2 -o %t.bad-entsize # RUN: yaml2obj %s --docnum=2 -o %t.bad-entsize
# RUN: llvm-readobj --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-LLVM # RUN: llvm-readobj --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-LLVM
# RUN: llvm-readelf --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-GNU # RUN: llvm-readelf --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-GNU
# BAD-ENTSIZE-LLVM: DynamicSection [ (2 entries) # BAD-ENTSIZE-LLVM: DynamicSection [ (2 entries)
# BAD-ENTSIZE-LLVM-NEXT: Tag Type Name/Value # BAD-ENTSIZE-LLVM-NEXT: Tag Type Name/Value
Show All 18 Lines - Name: .dynamic
EntSize: 0x2 EntSize: 0x2
Entries: Entries:
- Tag: DT_DEBUG - Tag: DT_DEBUG
Value: 0 Value: 0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Test handling of string references pointing past the end of the dynamic string table. ## Test handling of string references pointing past the end of the dynamic string table.
# RUN: yaml2obj %s --docnum=3 -o %t.bad-string # RUN: yaml2obj %s --docnum=3 -o %t.bad-string
# RUN: llvm-readobj --dynamic-table %t.bad-string 2>&1 | \ # RUN: llvm-readobj --dynamic-table %t.bad-string 2>&1 | \
# RUN: FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-LLVM -DFILE=%t.bad-string # RUN: FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-LLVM -DFILE=%t.bad-string
# RUN: llvm-readelf --dynamic-table %t.bad-string 2>&1 | \ # RUN: llvm-readelf --dynamic-table %t.bad-string 2>&1 | \
# RUN: FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-GNU -DFILE=%t.bad-string # RUN: FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-GNU -DFILE=%t.bad-string
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines Entries:
- Tag: DT_RPATH - Tag: DT_RPATH
Value: 7 Value: 7
- Tag: DT_RUNPATH - Tag: DT_RUNPATH
Value: 8 Value: 8
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1010 VAddr: 0x1010
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Test handling of DT_STRTAB pointing outside the file's address space. ## Test handling of DT_STRTAB pointing outside the file's address space.
# RUN: yaml2obj %s --docnum=4 -o %t.bad-strtab # RUN: yaml2obj %s --docnum=4 -o %t.bad-strtab
# RUN: llvm-readobj --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \ # RUN: llvm-readobj --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \
# RUN: FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR # RUN: FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR
# RUN: llvm-readelf --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \ # RUN: llvm-readelf --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \
# RUN: FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR # RUN: FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR
Show All 30 Lines Entries:
- Tag: DT_STRSZ - Tag: DT_STRSZ
Value: 10 Value: 10
- Tag: DT_NEEDED - Tag: DT_NEEDED
Value: 1 Value: 1
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Test handling of other d_ptr tags pointing outside the file's address space. ## Test handling of other d_ptr tags pointing outside the file's address space.
# RUN: yaml2obj %s --docnum=5 -o %t.bad-rela # RUN: yaml2obj %s --docnum=5 -o %t.bad-rela
# RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA # RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA
# RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA-GNU # RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA-GNU
# CHECK: warning: '[[FILE]]': Unable to parse DT_RELA: virtual address is not in any segment: 0x1000000 # CHECK: warning: '[[FILE]]': Unable to parse DT_RELA: virtual address is not in any segment: 0x1000000
Show All 18 Lines - Name: .dynamic
Address: 0x1000 Address: 0x1000
Entries: Entries:
- Tag: DT_RELA - Tag: DT_RELA
Value: 0x1000000 Value: 0x1000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
Symbols: [] Symbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Check how we handle cases when the dynamic string table is not null-terminated. ## Check how we handle cases when the dynamic string table is not null-terminated.
## Case A: the value of the DT_STRSZ tag is equal to the size of ## Case A: the value of the DT_STRSZ tag is equal to the size of
## the not null-terminated dynamic string table. ## the not null-terminated dynamic string table.
# RUN: yaml2obj %s -DSTRSZ=7 --docnum=6 -o %t6 # RUN: yaml2obj %s -DSTRSZ=7 --docnum=6 -o %t6
# RUN: llvm-readobj --dynamic-table %t6 2>&1 | \ # RUN: llvm-readobj --dynamic-table %t6 2>&1 | \
# RUN: FileCheck %s -DFILE=%t6 --implicit-check-not=warning: \ # RUN: FileCheck %s -DFILE=%t6 --implicit-check-not=warning: \
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines Entries:
Value: 4 Value: 4
- Tag: DT_RPATH - Tag: DT_RPATH
Value: 5 Value: 5
- Tag: DT_RUNPATH - Tag: DT_RUNPATH
Value: 6 Value: 6
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1100 VAddr: 0x1100
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Check that we emit an appropriate warning when the dynamic string table ends past the end of the file. ## Check that we emit an appropriate warning when the dynamic string table ends past the end of the file.
## Case A: the value of DT_STRSZ tag is set so that the string table ends ## Case A: the value of DT_STRSZ tag is set so that the string table ends
## right before the EOF. No warning should be emitted. ## right before the EOF. No warning should be emitted.
# RUN: yaml2obj %s -DSTRSZ=0x210 --docnum=6 -o %t9.1 # RUN: yaml2obj %s -DSTRSZ=0x210 --docnum=6 -o %t9.1
# RUN: llvm-readobj --dynamic-table %t9.1 | \ # RUN: llvm-readobj --dynamic-table %t9.1 | \
# RUN: FileCheck %s --implicit-check-not=warning: --check-prefix=BEFORE-THE-EOF # RUN: FileCheck %s --implicit-check-not=warning: --check-prefix=BEFORE-THE-EOF
Show All 31 Lines

llvm/test/tools/llvm-readobj/ELF/dynamic-no-pt-dynamic.test

Show All 26 Lines
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Address: 0x1000 Address: 0x1000
Entries: Entries:
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-not-in-pt-dynamic.test

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines Entries:
Value: 0x0 Value: 0x0
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1100 Address: 0x1100
AddressAlign: 0x100 AddressAlign: 0x100
Content: "00" Content: "00"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
## Case 2: The dynamic table found using the dynamic program header is different from the ## Case 2: The dynamic table found using the dynamic program header is different from the
## table found using the section header table. ## table found using the section header table.
# RUN: yaml2obj --docnum=2 %s -o %t2.o # RUN: yaml2obj --docnum=2 %s -o %t2.o
# RUN: llvm-readobj --dynamic-table %t2.o 2>&1 \ # RUN: llvm-readobj --dynamic-table %t2.o 2>&1 \
# RUN: | FileCheck -DFILE=%t2.o --check-prefixes=WARNING2,LLVM2 %s # RUN: | FileCheck -DFILE=%t2.o --check-prefixes=WARNING2,LLVM2 %s
# RUN: llvm-readelf --dynamic-table %t2.o 2>&1 \ # RUN: llvm-readelf --dynamic-table %t2.o 2>&1 \
Show All 29 Lines Entries:
Value: 0x0 Value: 0x0
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1100 Address: 0x1100
AddressAlign: 0x100 AddressAlign: 0x100
Content: "00000000000000000000000000000000" Content: "00000000000000000000000000000000"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text
## Case 3: Both dynamic tables found using SHT_DYNAMIC/PT_DYNAMIC are corrupted. ## Case 3: Both dynamic tables found using SHT_DYNAMIC/PT_DYNAMIC are corrupted.
# RUN: yaml2obj --docnum=3 %s -o %t3.o # RUN: yaml2obj --docnum=3 %s -o %t3.o
# RUN: llvm-readobj --dynamic-table %t3.o 2>&1 \ # RUN: llvm-readobj --dynamic-table %t3.o 2>&1 \
# RUN: | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s # RUN: | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s
# RUN: llvm-readelf --dynamic-table %t3.o 2>&1 \ # RUN: llvm-readelf --dynamic-table %t3.o 2>&1 \
# RUN: | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s # RUN: | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s
Show All 16 Lines - Name: .dynamic
Content: "00" Content: "00"
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1100 Address: 0x1100
AddressAlign: 0x100 AddressAlign: 0x100
Content: "00" Content: "00"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .text

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc-no-section-headers.test

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines## 0x168 - 0xb0 == 0xb8
Value: 0xb8 Value: 0xb8
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
- Name: .dynsym - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynstr
- Section: .dynamic
Section: .dynsym
Section: .dynstr
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
SectionHeaderTable: SectionHeaderTable:
NoHeaders: true NoHeaders: true

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc.test

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines## 0x30 == offset of .plt section in the segment.
Value: [[PLTRELSZ=0x10]] Value: [[PLTRELSZ=0x10]]
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
Symbols: Symbols:
- Name: foo - Name: foo
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .rela.dyn
- Section: .rela.dyn LastSec: .dynamic
- Section: .rel.dyn
- Section: .relr.dyn
- Section: .plt
- Section: .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-table-dtnull.s

Show All 19 LinesFileHeader:
Type: ET_EXEC Type: ET_EXEC
Sections: Sections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Entries: Entries:
- Tag: DT_DEBUG - Tag: DT_DEBUG
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# Sometimes .dynamic section content length can be greater than the # Sometimes .dynamic section content length can be greater than the
# length of its entries. In this case, we should not try to dump anything # length of its entries. In this case, we should not try to dump anything
# past the DT_NULL entry, which works as a terminator. # past the DT_NULL entry, which works as a terminator.
# RUN: yaml2obj --docnum=2 %s -o %t.o # RUN: yaml2obj --docnum=2 %s -o %t.o
# RUN: llvm-readobj --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-LLVM # RUN: llvm-readobj --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-LLVM
# RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-GNU # RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-GNU
Show All 20 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_DEBUG - Tag: DT_DEBUG
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-tags-machine-specific.test

Show All 33 Lines Entries:
Value: 0x10 Value: 0x10
- Tag: DT_HEXAGON_VER - Tag: DT_HEXAGON_VER
Value: 0x1000 Value: 0x1000
- Tag: DT_HEXAGON_PLT - Tag: DT_HEXAGON_PLT
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 2: Test that MIPS machine-specific tags can be dumped. ## Case 2: Test that MIPS machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=2 %s -o %t.mips # RUN: yaml2obj --docnum=2 %s -o %t.mips
# RUN: llvm-readobj --dynamic-table %t.mips \ # RUN: llvm-readobj --dynamic-table %t.mips \
# RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=LLVM-MIPS # RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=LLVM-MIPS
# RUN: llvm-readelf --dynamic-table %t.mips \ # RUN: llvm-readelf --dynamic-table %t.mips \
# RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=GNU-MIPS # RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=GNU-MIPS
▲ Show 20 Lines • Show All 198 Lines • ▼ Show 20 Lines Entries:
Value: 0x1000 Value: 0x1000
- Tag: DT_MIPS_RWPLT - Tag: DT_MIPS_RWPLT
Value: 0x1000 Value: 0x1000
- Tag: DT_MIPS_RLD_MAP_REL - Tag: DT_MIPS_RLD_MAP_REL
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 3: Test that PPC machine-specific tags can be dumped. ## Case 3: Test that PPC machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=3 %s -o %t.ppc # RUN: yaml2obj --docnum=3 %s -o %t.ppc
# RUN: llvm-readobj --dynamic-table %t.ppc | FileCheck %s --check-prefix=LLVM-PPC # RUN: llvm-readobj --dynamic-table %t.ppc | FileCheck %s --check-prefix=LLVM-PPC
# RUN: llvm-readelf --dynamic-table %t.ppc | FileCheck %s --check-prefix=GNU-PPC # RUN: llvm-readelf --dynamic-table %t.ppc | FileCheck %s --check-prefix=GNU-PPC
# LLVM-PPC: DynamicSection [ (3 entries) # LLVM-PPC: DynamicSection [ (3 entries)
# LLVM-PPC-NEXT: Tag Type Name/Value # LLVM-PPC-NEXT: Tag Type Name/Value
Show All 20 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_PPC_GOT - Tag: DT_PPC_GOT
Value: 0x200c0 Value: 0x200c0
- Tag: DT_PPC_OPT - Tag: DT_PPC_OPT
Value: 1 Value: 1
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 4: Test that PPC64 machine-specific tags can be dumped. ## Case 4: Test that PPC64 machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=4 %s -o %t.ppc64 # RUN: yaml2obj --docnum=4 %s -o %t.ppc64
# RUN: llvm-readobj --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=LLVM-PPC64 # RUN: llvm-readobj --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=LLVM-PPC64
# RUN: llvm-readelf --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=GNU-PPC64 # RUN: llvm-readelf --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=GNU-PPC64
# LLVM-PPC64: DynamicSection [ (2 entries) # LLVM-PPC64: DynamicSection [ (2 entries)
# LLVM-PPC64-NEXT: Tag Type Name/Value # LLVM-PPC64-NEXT: Tag Type Name/Value
Show All 16 LinesSections:
- Name: .dynamic - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Entries: Entries:
- Tag: DT_PPC64_GLINK - Tag: DT_PPC64_GLINK
Value: 0x1000 Value: 0x1000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Case 5: Test that AARCH64 machine-specific tags can be dumped. ## Case 5: Test that AARCH64 machine-specific tags can be dumped.
# RUN: yaml2obj --docnum=5 %s -o %t.aarch64 # RUN: yaml2obj --docnum=5 %s -o %t.aarch64
# RUN: llvm-readobj --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=LLVM-AARCH64 # RUN: llvm-readobj --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=LLVM-AARCH64
# RUN: llvm-readelf --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=GNU-AARCH64 # RUN: llvm-readelf --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=GNU-AARCH64
# LLVM-AARCH64: DynamicSection [ (3 entries) # LLVM-AARCH64: DynamicSection [ (3 entries)
# LLVM-AARCH64-NEXT: Tag Type Name/Value # LLVM-AARCH64-NEXT: Tag Type Name/Value
Show All 20 Lines - Name: .dynamic
Entries: Entries:
- Tag: DT_AARCH64_BTI_PLT - Tag: DT_AARCH64_BTI_PLT
Value: 1 Value: 1
- Tag: DT_AARCH64_PAC_PLT - Tag: DT_AARCH64_PAC_PLT
Value: 2 Value: 2
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-tags.test

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines## An OS specific tag.
- Tag: 0x6abcdef0 - Tag: 0x6abcdef0
Value: [[OSSPEC=0x9988776655443322]] Value: [[OSSPEC=0x9988776655443322]]
## A processor specific tags. ## A processor specific tags.
- Tag: 0x76543210 - Tag: 0x76543210
Value: [[PROCSPEC=0x5555666677778888]] Value: [[PROCSPEC=0x5555666677778888]]
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1010 VAddr: 0x1010
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
# RUN: yaml2obj %s --docnum=1 -DBITS=32 -DSYMBOLIC=0x12345678 -DDEBUG=0xfedcba09 \ # RUN: yaml2obj %s --docnum=1 -DBITS=32 -DSYMBOLIC=0x12345678 -DDEBUG=0xfedcba09 \
# RUN: -DTEXTREL=0x11223344 -DBINDNOW=0x88776655 -DFLAGS=0xffffffff \ # RUN: -DTEXTREL=0x11223344 -DBINDNOW=0x88776655 -DFLAGS=0xffffffff \
# RUN: -DUNKNOWN=0x87654321 -DOSSPEC=0x99887766 -DPROCSPEC=0x55556666 -o %t2 # RUN: -DUNKNOWN=0x87654321 -DOSSPEC=0x99887766 -DPROCSPEC=0x55556666 -o %t2
# RUN: llvm-readobj --dynamic-table %t2 \ # RUN: llvm-readobj --dynamic-table %t2 \
# RUN: | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines # RUN: | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines
# RUN: llvm-readobj -d %t2 | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines # RUN: llvm-readobj -d %t2 | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines
# RUN: llvm-readelf --dynamic-table %t2 \ # RUN: llvm-readelf --dynamic-table %t2 \
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines - Name: .note.gnu.build-id
Address: 0x0000000000400120 Address: 0x0000000000400120
AddressAlign: 0x0000000000000004 AddressAlign: 0x0000000000000004
Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
- Name: .note.gnu.gold-version - Name: .note.gnu.gold-version
Type: SHT_NOTE Type: SHT_NOTE
AddressAlign: 0x0000000000000004 AddressAlign: 0x0000000000000004
Content: 040000000900000004000000474E5500676F6C6420312E3131000000 Content: 040000000900000004000000474E5500676F6C6420312E3131000000
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
FileSize: 0x20 FileSize: 0x20
Sections: FirstSec: .note.gnu.build-id
- Section: .note.gnu.build-id LastSec: .note.gnu.build-id
## Test tools report an error if a note section has an invalid offset ## Test tools report an error if a note section has an invalid offset
## that goes past the end of file. ## that goes past the end of file.
# RUN: yaml2obj --docnum=2 %s -o %t2.so # RUN: yaml2obj --docnum=2 %s -o %t2.so
# RUN: not llvm-readelf --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1 # RUN: not llvm-readelf --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1
# RUN: not llvm-readobj --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1 # RUN: not llvm-readobj --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note - Name: .note
Type: SHT_NOTE Type: SHT_NOTE
Notes: [] Notes: []
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
FileSize: 0xffff0000 FileSize: 0xffff0000
Sections: FirstSec: .note
- Section: .note LastSec: .note
jhendersonUnsubmitted
Done
ReplyInline Actions
FirstSec: .note
- LastSec: .note
+ LastSec: .note
## Check we report a warning when we are unable to locate the PT_NOTE
jhenderson:
## Check we report a warning when we are unable to locate the PT_NOTE ## Check we report a warning when we are unable to locate the PT_NOTE
## segment because of broken program headers. ## segment because of broken program headers.
# RUN: yaml2obj --docnum=1 -DPHENTSIZE=1 -DSHNUM=0 %s -o %t6.so # RUN: yaml2obj --docnum=1 -DPHENTSIZE=1 -DSHNUM=0 %s -o %t6.so
# RUN: llvm-readelf --notes %t6.so 2>&1 | FileCheck %s -DFILE=%t6.so --check-prefix=PHENTSIZE-WARN-GNU # RUN: llvm-readelf --notes %t6.so 2>&1 | FileCheck %s -DFILE=%t6.so --check-prefix=PHENTSIZE-WARN-GNU
# RUN: llvm-readobj --notes %t6.so 2>&1 | FileCheck %s -DFILE=%t6.so --check-prefix=PHENTSIZE-WARN-LLVM # RUN: llvm-readobj --notes %t6.so 2>&1 | FileCheck %s -DFILE=%t6.so --check-prefix=PHENTSIZE-WARN-LLVM
# PHENTSIZE-WARN-GNU: warning: '[[FILE]]': unable to read program headers to locate the PT_DYNAMIC segment: invalid e_phentsize: 1 # PHENTSIZE-WARN-GNU: warning: '[[FILE]]': unable to read program headers to locate the PT_DYNAMIC segment: invalid e_phentsize: 1
# PHENTSIZE-WARN-GNU: warning: '[[FILE]]': unable to read program headers to locate the PT_NOTE segment: invalid e_phentsize: 1 # PHENTSIZE-WARN-GNU: warning: '[[FILE]]': unable to read program headers to locate the PT_NOTE segment: invalid e_phentsize: 1
# PHENTSIZE-WARN-LLVM: Notes [ # PHENTSIZE-WARN-LLVM: Notes [
# PHENTSIZE-WARN-LLVM-NEXT: warning: '[[FILE]]': unable to read program headers to locate the PT_NOTE segment: invalid e_phentsize: 1 # PHENTSIZE-WARN-LLVM-NEXT: warning: '[[FILE]]': unable to read program headers to locate the PT_NOTE segment: invalid e_phentsize: 1
# PHENTSIZE-WARN-LLVM-NEXT: ] # PHENTSIZE-WARN-LLVM-NEXT: ]

llvm/test/tools/llvm-readobj/ELF/gnu-section-mapping.test

Show All 33 Lines - Name: .bar.begin
Address: 0x2000 Address: 0x2000
Size: 0x3 Size: 0x3
- Name: .bar.end - Name: .bar.end
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x4 Size: 0x4
ProgramHeaders: ProgramHeaders:
## Case 1: an arbitrary segment with sections. ## Case 1: an arbitrary segment with sections.
- Type: PT_PHDR - Type: PT_PHDR
Flags: [ PF_W ] Flags: [ PF_W ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 2: another segment with different sections. ## Case 2: another segment with different sections.
- Type: PT_PHDR - Type: PT_PHDR
Flags: [ PF_X ] Flags: [ PF_X ]
VAddr: 0x2000 VAddr: 0x2000
Sections: FirstSec: .bar.begin
- Section: .bar.begin LastSec: .bar.end
- Section: .bar.end
## Check that --section-mapping=false --program-headers produces just program headers. ## Check that --section-mapping=false --program-headers produces just program headers.
# RUN: llvm-readelf --section-mapping=false --program-headers %t64.elf \ # RUN: llvm-readelf --section-mapping=false --program-headers %t64.elf \
# RUN: | FileCheck %s --check-prefix=SEC-MAPPING-FALSE --implicit-check-not="Section to Segment mapping:" # RUN: | FileCheck %s --check-prefix=SEC-MAPPING-FALSE --implicit-check-not="Section to Segment mapping:"
# SEC-MAPPING-FALSE: Program Headers: # SEC-MAPPING-FALSE: Program Headers:
## Check that only one copy of the section/segment mapping table is produced ## Check that only one copy of the section/segment mapping table is produced
Show All 22 Lines

llvm/test/tools/llvm-readobj/ELF/gnuhash.test

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines - Name: aaa
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: bbb - Name: bbb
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: ccc - Name: ccc
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: ddd - Name: ddd
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check we report a warning if there is no dynamic symbol section in the object. ## Check we report a warning if there is no dynamic symbol section in the object.
# RUN: yaml2obj --docnum=2 %s -o %t.nodynsym # RUN: yaml2obj --docnum=2 %s -o %t.nodynsym
# RUN: llvm-readobj --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM # RUN: llvm-readobj --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM
# RUN: llvm-readelf --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM # RUN: llvm-readelf --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM
# NODYNSYM: GnuHashTable { # NODYNSYM: GnuHashTable {
Show All 25 Lines - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Entries: Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check what we do when the index of the first symbol in the dynamic symbol table ## Check what we do when the index of the first symbol in the dynamic symbol table
## included in the hash table is larger than the number of dynamic symbols. ## included in the hash table is larger than the number of dynamic symbols.
# RUN: yaml2obj --docnum=3 %s -o %t.brokensymndx # RUN: yaml2obj --docnum=3 %s -o %t.brokensymndx
# RUN: llvm-readobj --gnu-hash-table %t.brokensymndx 2>&1 \ # RUN: llvm-readobj --gnu-hash-table %t.brokensymndx 2>&1 \
# RUN: | FileCheck %s -DFILE=%t.brokensymndx --check-prefix=SYMNDX # RUN: | FileCheck %s -DFILE=%t.brokensymndx --check-prefix=SYMNDX
# RUN: llvm-readelf --gnu-hash-table %t.brokensymndx 2>&1 \ # RUN: llvm-readelf --gnu-hash-table %t.brokensymndx 2>&1 \
Show All 32 Lines Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: aaa - Name: aaa
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check we emit a warning when the dynamic symbol table is empty. ## Check we emit a warning when the dynamic symbol table is empty.
## A valid dynamic symbol table should have at least one symbol: the symbol with index 0. ## A valid dynamic symbol table should have at least one symbol: the symbol with index 0.
# RUN: yaml2obj --docnum=4 %s -o %t.emptydynsym # RUN: yaml2obj --docnum=4 %s -o %t.emptydynsym
# RUN: llvm-readobj --gnu-hash-table %t.emptydynsym 2>&1 \ # RUN: llvm-readobj --gnu-hash-table %t.emptydynsym 2>&1 \
# RUN: | FileCheck %s -DFILE=%t.emptydynsym --check-prefix=EMPTY-DYNSYM # RUN: | FileCheck %s -DFILE=%t.emptydynsym --check-prefix=EMPTY-DYNSYM
# RUN: llvm-readelf --gnu-hash-table %t.emptydynsym 2>&1 \ # RUN: llvm-readelf --gnu-hash-table %t.emptydynsym 2>&1 \
Show All 32 Lines Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
- Name: .dynsym - Name: .dynsym
Type: SHT_DYNSYM Type: SHT_DYNSYM
Size: 0 Size: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Linkers might produce an empty no-op SHT_GNU_HASH section when ## Linkers might produce an empty no-op SHT_GNU_HASH section when
## there are no dynamic symbols or when all dynamic symbols are undefined. ## there are no dynamic symbols or when all dynamic symbols are undefined.
## Such sections normally have a single zero entry in the bloom ## Such sections normally have a single zero entry in the bloom
## filter, a single zero entry in the hash bucket and no values. ## filter, a single zero entry in the hash bucket and no values.
## ##
## The index of the first symbol in the dynamic symbol table ## The index of the first symbol in the dynamic symbol table
## included in the hash table can be set to the number of dynamic symbols, ## included in the hash table can be set to the number of dynamic symbols,
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines - Name: .dynamic
Link: 0 Link: 0
Entries: Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check we report a proper warning when a hash table goes past the end of the file. ## Check we report a proper warning when a hash table goes past the end of the file.
## Case A: the 'maskwords' field is set so that the table goes past the end of the file. ## Case A: the 'maskwords' field is set so that the table goes past the end of the file.
# RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_X86_64 -D MASKWORDS=4294967295 %s -o %t.err.maskwords # RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_X86_64 -D MASKWORDS=4294967295 %s -o %t.err.maskwords
# RUN: llvm-readobj --gnu-hash-table %t.err.maskwords 2>&1 | \ # RUN: llvm-readobj --gnu-hash-table %t.err.maskwords 2>&1 | \
# RUN: FileCheck %s -DFILE=%t.err.maskwords -DMASKWORDS=4294967295 -DNBUCKETS=3 --check-prefix=ERR # RUN: FileCheck %s -DFILE=%t.err.maskwords -DMASKWORDS=4294967295 -DNBUCKETS=3 --check-prefix=ERR
# RUN: llvm-readelf --gnu-hash-table %t.err.maskwords 2>&1 | \ # RUN: llvm-readelf --gnu-hash-table %t.err.maskwords 2>&1 | \
Show All 21 Lines

llvm/test/tools/llvm-readobj/ELF/hash-histogram.test

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines## sizeof(.hash) == 0x28.
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: a - Name: a
- Name: b - Name: b
- Name: c - Name: c
- Name: d - Name: d
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .gnu.hash
- Section: .dynamic
## Show that we report a warning for a hash table which contains an entry of ## Show that we report a warning for a hash table which contains an entry of
## the bucket array pointing to a cycle. ## the bucket array pointing to a cycle.
# RUN: yaml2obj --docnum=2 %s -o %t2.o # RUN: yaml2obj --docnum=2 %s -o %t2.o
# RUN: llvm-readelf --elf-hash-histogram 2>&1 %t2.o | FileCheck -DFILE=%t2.o %s --check-prefix=BROKEN # RUN: llvm-readelf --elf-hash-histogram 2>&1 %t2.o | FileCheck -DFILE=%t2.o %s --check-prefix=BROKEN
# BROKEN: warning: '[[FILE]]': .hash section is invalid: bucket 1: a cycle was detected in the linked chain # BROKEN: warning: '[[FILE]]': .hash section is invalid: bucket 1: a cycle was detected in the linked chain
Show All 22 Lines
## which is the start of PT_LOAD, i.e. the file offset of .hash. ## which is the start of PT_LOAD, i.e. the file offset of .hash.
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain. ## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain.
## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes. ## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes.
# RUN: yaml2obj --docnum=3 %s -o %t3.o # RUN: yaml2obj --docnum=3 %s -o %t3.o
# RUN: llvm-readelf --elf-hash-histogram %t3.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t3.o # RUN: llvm-readelf --elf-hash-histogram %t3.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t3.o
# ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}} # ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}}
Show All 16 Lines Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x239 Value: 0x239
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
FileSize: 0x23a FileSize: 0x23a
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check we report a warning when the hash table goes past the end of the file. ## Check we report a warning when the hash table goes past the end of the file.
## Case A.1: the hash table ends right before the EOF. We have a broken nbucket ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
## field that has a value larger than the number of buckets. ## field that has a value larger than the number of buckets.
# RUN: yaml2obj --docnum=4 %s -o %t4.1.o -DNBUCKET=0x5d -DNCHAIN=0x1 # RUN: yaml2obj --docnum=4 %s -o %t4.1.o -DNBUCKET=0x5d -DNCHAIN=0x1
# RUN: llvm-readelf --elf-hash-histogram %t4.1.o 2>&1 | \ # RUN: llvm-readelf --elf-hash-histogram %t4.1.o 2>&1 | \
# RUN: FileCheck %s --implicit-check-not={{.}} --allow-empty # RUN: FileCheck %s --implicit-check-not={{.}} --allow-empty
Show All 40 Lines - Name: .dynamic
Flags: [ SHF_WRITE, SHF_ALLOC ] Flags: [ SHF_WRITE, SHF_ALLOC ]
Entries: Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check we dump a histogram for the .gnu.hash table even when the .hash table is skipped. ## Check we dump a histogram for the .gnu.hash table even when the .hash table is skipped.
## Case A: the .hash table has no data to build histogram and it is skipped. ## Case A: the .hash table has no data to build histogram and it is skipped.
# RUN: yaml2obj --docnum=5 %s -o %t5.o # RUN: yaml2obj --docnum=5 %s -o %t5.o
# RUN: llvm-readelf --elf-hash-histogram %t5.o 2>&1 | \ # RUN: llvm-readelf --elf-hash-histogram %t5.o 2>&1 | \
# RUN: FileCheck %s --check-prefix=GNU-HASH --implicit-check-not="Histogram" # RUN: FileCheck %s --check-prefix=GNU-HASH --implicit-check-not="Histogram"
Show All 37 Lines Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
## sizeof(.hash) == 0x14. ## sizeof(.hash) == 0x14.
Value: 0x14 Value: 0x14
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .gnu.hash
- Section: .dynamic
## Check we report a proper warning when the GNU hash table goes past the end of the file. ## Check we report a proper warning when the GNU hash table goes past the end of the file.
## Case A: the 'maskwords' field is set so that the GNU hash table goes past the end of the file. ## Case A: the 'maskwords' field is set so that the GNU hash table goes past the end of the file.
# RUN: yaml2obj --docnum=6 -D MASKWORDS=0x80000000 %s -o %t7 # RUN: yaml2obj --docnum=6 -D MASKWORDS=0x80000000 %s -o %t7
# RUN: llvm-readelf --elf-hash-histogram %t7 2>&1 | \ # RUN: llvm-readelf --elf-hash-histogram %t7 2>&1 | \
# RUN: FileCheck %s -DFILE=%t7 --check-prefix=ERR5 --implicit-check-not="Histogram" # RUN: FileCheck %s -DFILE=%t7 --check-prefix=ERR5 --implicit-check-not="Histogram"
Show All 29 Lines - Name: .dynamic
Link: .dynstr Link: .dynstr
Entries: Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Linkers might produce an empty no-op SHT_GNU_HASH section when ## Linkers might produce an empty no-op SHT_GNU_HASH section when
## there are no dynamic symbols or when all dynamic symbols are undefined. ## there are no dynamic symbols or when all dynamic symbols are undefined.
## Such sections normally have a single zero entry in the bloom ## Such sections normally have a single zero entry in the bloom
## filter, a single zero entry in the hash bucket and no values. ## filter, a single zero entry in the hash bucket and no values.
## ##
## The index of the first symbol in the dynamic symbol table ## The index of the first symbol in the dynamic symbol table
## included in the hash table can be set to the number of dynamic symbols, ## included in the hash table can be set to the number of dynamic symbols,
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines - Name: .dynamic
Link: .dynstr Link: .dynstr
Entries: Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check we report warnings when the dynamic symbol table is absent or empty. ## Check we report warnings when the dynamic symbol table is absent or empty.
## The code locates the dynamic symbol table by the section type. Use SHT_PROGBITS to hide it. ## The code locates the dynamic symbol table by the section type. Use SHT_PROGBITS to hide it.
# RUN: yaml2obj --docnum=8 -DTYPE=SHT_PROGBITS %s -o %t12 # RUN: yaml2obj --docnum=8 -DTYPE=SHT_PROGBITS %s -o %t12
# RUN: llvm-readelf --elf-hash-histogram %t12 2>&1 | \ # RUN: llvm-readelf --elf-hash-histogram %t12 2>&1 | \
# RUN: FileCheck %s -DFILE=%t12 --check-prefix=ERR7 # RUN: FileCheck %s -DFILE=%t12 --check-prefix=ERR7
Show All 27 Lines Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
- Name: .dynsym - Name: .dynsym
Type: [[TYPE]] Type: [[TYPE]]
Size: 0 Size: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .gnu.hash
jhendersonUnsubmitted
Done
ReplyInline Actions
FirstSec: .gnu.hash
- LastSec: .gnu.hash
+ LastSec: .gnu.hash
jhenderson:

llvm/test/tools/llvm-readobj/ELF/hash-symbols.test

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines - Name: [[NAME=eee]]
Binding: STB_GLOBAL Binding: STB_GLOBAL
Type: [[TYPE=STT_NOTYPE]] Type: [[TYPE=STT_NOTYPE]]
- Name: [[NAME=bbb]] - Name: [[NAME=bbb]]
Section: .hash Section: .hash
Binding: STB_WEAK Binding: STB_WEAK
Value: 0x0000000000001001 Value: 0x0000000000001001
Type: [[TYPE=STT_NOTYPE]] Type: [[TYPE=STT_NOTYPE]]
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .gnu.hash
- Section: .dynamic
## Check what we print for unnamed section symbols. ## Check what we print for unnamed section symbols.
# RUN: yaml2obj --docnum=1 -DBITS=64 -DTYPE=STT_SECTION -DNAME="''" %s -o %t1-sec-syms.so # RUN: yaml2obj --docnum=1 -DBITS=64 -DTYPE=STT_SECTION -DNAME="''" %s -o %t1-sec-syms.so
# RUN: llvm-readelf --hash-symbols %t1-sec-syms.so 2>&1 | \ # RUN: llvm-readelf --hash-symbols %t1-sec-syms.so 2>&1 | \
# RUN: FileCheck %s -DFILE=%t1-sec-syms.so --check-prefix=UNNAMED-SEC-SYMS # RUN: FileCheck %s -DFILE=%t1-sec-syms.so --check-prefix=UNNAMED-SEC-SYMS
# UNNAMED-SEC-SYMS: Symbol table of .hash for image: # UNNAMED-SEC-SYMS: Symbol table of .hash for image:
# UNNAMED-SEC-SYMS-NEXT: Num {{.*}} Ndx Name # UNNAMED-SEC-SYMS-NEXT: Num {{.*}} Ndx Name
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 LinesDynamicSymbols:
- Name: eee - Name: eee
Section: .dynamic Section: .dynamic
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: bbb - Name: bbb
Section: .hash Section: .hash
Binding: STB_WEAK Binding: STB_WEAK
Value: 0x0000000000001001 Value: 0x0000000000001001
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check the output when only .gnu.hash section is present. ## Check the output when only .gnu.hash section is present.
# RUN: yaml2obj --docnum=3 %s -o %t3-32.so # RUN: yaml2obj --docnum=3 %s -o %t3-32.so
# RUN: llvm-readelf --hash-symbols %t3-32.so \ # RUN: llvm-readelf --hash-symbols %t3-32.so \
# RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ONLY-GNUHASH-32 # RUN: | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ONLY-GNUHASH-32
# ONLY-GNUHASH-32: Symbol table of .gnu.hash for image: # ONLY-GNUHASH-32: Symbol table of .gnu.hash for image:
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 LinesDynamicSymbols:
- Name: eee - Name: eee
Section: .gnu.hash Section: .gnu.hash
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: bbb - Name: bbb
Section: .dynamic Section: .dynamic
Binding: STB_WEAK Binding: STB_WEAK
Value: 0x0000000000001001 Value: 0x0000000000001001
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Show that if there are no hash sections, we do not print anything. ## Show that if there are no hash sections, we do not print anything.
# RUN: yaml2obj --docnum=4 %s -o %t4.so # RUN: yaml2obj --docnum=4 %s -o %t4.so
# RUN: llvm-readelf --hash-symbols %t4.so \ # RUN: llvm-readelf --hash-symbols %t4.so \
# RUN: | FileCheck %s --check-prefix NO-HASH --allow-empty # RUN: | FileCheck %s --check-prefix NO-HASH --allow-empty
# NO-HASH-NOT: {{.}} # NO-HASH-NOT: {{.}}
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines - Name: .text.foo
Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ] Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
Size: 0x40 Size: 0x40
Address: 0x2000 Address: 0x2000
AddressAlign: 0x2000 AddressAlign: 0x2000
DynamicSymbols: DynamicSymbols:
- Name: _Z3fooi - Name: _Z3fooi
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
VAddr: 0x0 VAddr: 0x0
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .text.foo
- Section: .dynsym
- Section: .dynamic
- Section: .text.foo
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Show that we report a warning for a hash table which contains an entry of ## Show that we report a warning for a hash table which contains an entry of
## the bucket array pointing to a cycle. ## the bucket array pointing to a cycle.
# RUN: yaml2obj --docnum=5 %s -o %t5.so # RUN: yaml2obj --docnum=5 %s -o %t5.so
# RUN: llvm-readelf --hash-symbols %t5.so 2>&1 | FileCheck %s -DFILE=%t5.so --check-prefix=BROKEN # RUN: llvm-readelf --hash-symbols %t5.so 2>&1 | FileCheck %s -DFILE=%t5.so --check-prefix=BROKEN
# BROKEN: Symbol table of .hash for image: # BROKEN: Symbol table of .hash for image:
Show All 19 Lines
## p_offset + (p_vaddr - DT_HASH) = p_offset + (0 - 0) = p_offset, ## p_offset + (p_vaddr - DT_HASH) = p_offset + (0 - 0) = p_offset,
## which is the start of PT_LOAD, i.e. the file offset of .hash. ## which is the start of PT_LOAD, i.e. the file offset of .hash.
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: aaa - Name: aaa
- Name: bbb - Name: bbb
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain. ## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain.
## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes. ## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes.
# RUN: yaml2obj --docnum=6 %s -o %t6.o # RUN: yaml2obj --docnum=6 %s -o %t6.o
# RUN: llvm-readelf --hash-symbols %t6.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t6.o # RUN: llvm-readelf --hash-symbols %t6.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t6.o
# ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}} # ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}}
Show All 16 Lines Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x239 Value: 0x239
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
FileSize: 0x23a FileSize: 0x23a
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check we report a warning when the hash table goes past the end of the file. ## Check we report a warning when the hash table goes past the end of the file.
## Case A.1: the hash table ends right before the EOF. We have a broken nbucket ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
## field that has a value larger than the number of buckets. ## field that has a value larger than the number of buckets.
# RUN: yaml2obj --docnum=7 %s -o %t7.1.o -DNBUCKET=0x5d # RUN: yaml2obj --docnum=7 %s -o %t7.1.o -DNBUCKET=0x5d
# RUN: llvm-readelf --hash-symbols %t7.1.o 2>&1 | FileCheck %s --check-prefix=NOERR1 # RUN: llvm-readelf --hash-symbols %t7.1.o 2>&1 | FileCheck %s --check-prefix=NOERR1
# NOERR1: Symbol table of .hash for image: # NOERR1: Symbol table of .hash for image:
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines - Name: .dynamic
Flags: [ SHF_WRITE, SHF_ALLOC ] Flags: [ SHF_WRITE, SHF_ALLOC ]
Entries: Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check we report a proper warning when a GNU hash table goes past the end of the file. ## Check we report a proper warning when a GNU hash table goes past the end of the file.
## Case A: the 'maskwords' field is set so that the table goes past the end of the file. ## Case A: the 'maskwords' field is set so that the table goes past the end of the file.
# RUN: yaml2obj --docnum=8 -D MASKWORDS=4294967295 %s -o %t.err.maskwords # RUN: yaml2obj --docnum=8 -D MASKWORDS=4294967295 %s -o %t.err.maskwords
# RUN: llvm-readelf --hash-symbols %t.err.maskwords 2>&1 | \ # RUN: llvm-readelf --hash-symbols %t.err.maskwords 2>&1 | \
# RUN: FileCheck %s -DFILE=%t.err.maskwords --check-prefix=ERR4 # RUN: FileCheck %s -DFILE=%t.err.maskwords --check-prefix=ERR4
Show All 39 Lines - Name: aaa
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: bbb - Name: bbb
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: ccc - Name: ccc
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Name: ddd - Name: ddd
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## Check the behavior when the dynamic symbol table is empty or not found. ## Check the behavior when the dynamic symbol table is empty or not found.
## Case A.1: Check we report a warning when the dynamic symbol table is empty and we attempt to print hash symbols ## Case A.1: Check we report a warning when the dynamic symbol table is empty and we attempt to print hash symbols
## from the .hash table. The number of symbols in the dynamic symbol table can be calculated from its size ## from the .hash table. The number of symbols in the dynamic symbol table can be calculated from its size
## or derived from the Chain vector of the .hash table. Make both ways to return a zero to do the check. ## or derived from the Chain vector of the .hash table. Make both ways to return a zero to do the check.
# RUN: yaml2obj --docnum=9 %s -o %t9.1.so # RUN: yaml2obj --docnum=9 %s -o %t9.1.so
# RUN: llvm-readelf --hash-symbols %t9.1.so 2>&1 | FileCheck %s -DFILE=%t9.1.so --check-prefix=DYNSYM-EMPTY-HASH # RUN: llvm-readelf --hash-symbols %t9.1.so 2>&1 | FileCheck %s -DFILE=%t9.1.so --check-prefix=DYNSYM-EMPTY-HASH
Show All 31 Lines## 0x54 + 0x2c == 0x80 == .dynstr offset.
- Name: .dynstr - Name: .dynstr
Type: SHT_STRTAB Type: SHT_STRTAB
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
- Name: .dynsym - Name: .dynsym
Type: [[DYNSYMTYPE=SHT_DYNSYM]] Type: [[DYNSYMTYPE=SHT_DYNSYM]]
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0 Size: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynstr
- Section: .dynamic
- Section: .dynstr
## Case A.2: similar to A.1, but now check that we report a warning when the dynamic symbol table was not found. ## Case A.2: similar to A.1, but now check that we report a warning when the dynamic symbol table was not found.
## To do that, set the type of the .dynsym to SHT_PROGBITS to hide it. ## To do that, set the type of the .dynsym to SHT_PROGBITS to hide it.
# RUN: yaml2obj --docnum=9 -DDYNSYMTYPE=SHT_PROGBITS %s -o %t9.2.so # RUN: yaml2obj --docnum=9 -DDYNSYMTYPE=SHT_PROGBITS %s -o %t9.2.so
# RUN: llvm-readelf --hash-symbols %t9.2.so 2>&1 | FileCheck %s -DFILE=%t9.2.so --check-prefix=DYNSYM-NOTFOUND-HASH # RUN: llvm-readelf --hash-symbols %t9.2.so 2>&1 | FileCheck %s -DFILE=%t9.2.so --check-prefix=DYNSYM-NOTFOUND-HASH
# DYNSYM-NOTFOUND-HASH: Symbol table of .hash for image: # DYNSYM-NOTFOUND-HASH: Symbol table of .hash for image:
# DYNSYM-NOTFOUND-HASH-NEXT: Num Buc: Value Size Type Bind Vis Ndx Name # DYNSYM-NOTFOUND-HASH-NEXT: Num Buc: Value Size Type Bind Vis Ndx Name
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines## 0x54 + 0x3c == 0x80 == .dynstr offset.
Value: 0x0 Value: 0x0
- Name: .dynstr - Name: .dynstr
Type: SHT_STRTAB Type: SHT_STRTAB
- Name: .dynsym - Name: .dynsym
Type: [[DYNSYMTYPE=SHT_DYNSYM]] Type: [[DYNSYMTYPE=SHT_DYNSYM]]
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0 Size: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynstr
- Section: .dynamic
- Section: .dynstr
## In this case we have a broken value in the hash buckets array. Normally it contains an ## In this case we have a broken value in the hash buckets array. Normally it contains an
## index into the dynamic symbol table and also is used to get a hash value from the hash values array. ## index into the dynamic symbol table and also is used to get a hash value from the hash values array.
## llvm-readelf attempts to read a symbol that is past the end of the dynamic symbol table. ## llvm-readelf attempts to read a symbol that is past the end of the dynamic symbol table.
# RUN: yaml2obj --docnum=11 -DVALUE=0x2 %s -o %t11.past.dynsym.so # RUN: yaml2obj --docnum=11 -DVALUE=0x2 %s -o %t11.past.dynsym.so
# RUN: llvm-readelf --hash-symbols %t11.past.dynsym.so 2>&1 | \ # RUN: llvm-readelf --hash-symbols %t11.past.dynsym.so 2>&1 | \
# RUN: FileCheck %s -DFILE=%t11.past.dynsym.so --check-prefix=BUCKET-PAST-DYNSYM # RUN: FileCheck %s -DFILE=%t11.past.dynsym.so --check-prefix=BUCKET-PAST-DYNSYM
Show All 28 Lines Entries:
- Tag: DT_GNU_HASH - Tag: DT_GNU_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: DynamicSymbols:
- Name: foo - Name: foo
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R, PF_X ] Flags: [ PF_R, PF_X ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .dynamic
- Section: .dynamic
## In this case we are unable to read a hash value for a symbol with ## In this case we are unable to read a hash value for a symbol with
## an index that is less than the index of the first hashed symbol. ## an index that is less than the index of the first hashed symbol.
# RUN: yaml2obj --docnum=11 -DSYMNDX=0x2 -DVALUE=0x1 %s -o %t11.first.hashed.so # RUN: yaml2obj --docnum=11 -DSYMNDX=0x2 -DVALUE=0x1 %s -o %t11.first.hashed.so
# RUN: llvm-readelf --hash-symbols %t11.first.hashed.so 2>&1 | \ # RUN: llvm-readelf --hash-symbols %t11.first.hashed.so 2>&1 | \
# RUN: FileCheck %s -DFILE=%t11.first.hashed.so --check-prefix=FIRST-HASHED # RUN: FileCheck %s -DFILE=%t11.first.hashed.so --check-prefix=FIRST-HASHED
Show All 21 Lines

llvm/test/tools/llvm-readobj/ELF/hash-table.test

Show All 32 Lines - Name: .dynamic
Type: SHT_DYNAMIC Type: SHT_DYNAMIC
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Entries: Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Document that we ignore the sh_entsize value when dumping the hash section. ## Document that we ignore the sh_entsize value when dumping the hash section.
## Implementation assumes that the size of entries is 4, matching the ELF specification. ## Implementation assumes that the size of entries is 4, matching the ELF specification.
# RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=64 -DMACHINE=EM_X86_64 %s -o %t.x64.ent8 # RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=64 -DMACHINE=EM_X86_64 %s -o %t.x64.ent8
# RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=32 -DMACHINE=EM_386 %s -o %t.x32.ent8 # RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=32 -DMACHINE=EM_386 %s -o %t.x32.ent8
# RUN: llvm-readobj --hash-table %t.x64.ent8 | FileCheck %s --check-prefix=HASH # RUN: llvm-readobj --hash-table %t.x64.ent8 | FileCheck %s --check-prefix=HASH
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines - Name: .dynamic
Entries: Entries:
- Tag: [[DYNTAG=DT_HASH]] - Tag: [[DYNTAG=DT_HASH]]
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
SectionHeaderTable: SectionHeaderTable:
NoHeaders: [[NOHEADERS=false]] NoHeaders: [[NOHEADERS=false]]
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x10 VAddr: 0x10
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
## Document we don't report a warning when the value of the sh_entsize field of the SHT_HASH section is not 4. ## Document we don't report a warning when the value of the sh_entsize field of the SHT_HASH section is not 4.
# RUN: yaml2obj --docnum=2 -DENTSIZE=0xff %s -o %t.ent.size # RUN: yaml2obj --docnum=2 -DENTSIZE=0xff %s -o %t.ent.size
# RUN: llvm-readobj --hash-table %t.ent.size 2>&1 | \ # RUN: llvm-readobj --hash-table %t.ent.size 2>&1 | \
# RUN: FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning: # RUN: FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning:
# RUN: llvm-readelf --hash-table %t.ent.size 2>&1 | \ # RUN: llvm-readelf --hash-table %t.ent.size 2>&1 | \
# RUN: FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning: # RUN: FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning:
Show All 38 Lines Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x239 Value: 0x239
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
FileSize: 0x23a FileSize: 0x23a
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Check we report a warning when the hash table goes past the end of the file. ## Check we report a warning when the hash table goes past the end of the file.
## Case A.1: the hash table ends right before the EOF. We have a broken nbucket ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
## field that has a value larger than the number of buckets. ## field that has a value larger than the number of buckets.
# RUN: yaml2obj --docnum=4 %s -o %t5.1.o -DNBUCKET=0x5d -DNCHAIN=0x1 # RUN: yaml2obj --docnum=4 %s -o %t5.1.o -DNBUCKET=0x5d -DNCHAIN=0x1
# RUN: llvm-readelf --hash-table %t5.1.o 2>&1 | \ # RUN: llvm-readelf --hash-table %t5.1.o 2>&1 | \
# RUN: FileCheck %s --check-prefix=NOERR1 --implicit-check-not="warning:" # RUN: FileCheck %s --check-prefix=NOERR1 --implicit-check-not="warning:"
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines - Name: .dynamic
Flags: [ SHF_WRITE, SHF_ALLOC ] Flags: [ SHF_WRITE, SHF_ALLOC ]
Entries: Entries:
- Tag: DT_HASH - Tag: DT_HASH
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
DynamicSymbols: [] DynamicSymbols: []
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynamic
- Section: .dynamic
## Show we do not duplicate warnings when printing both the hash table and the hash histogram. ## Show we do not duplicate warnings when printing both the hash table and the hash histogram.
## Note that --elf-hash-histogram is only implemented for llvm-readelf currently. ## Note that --elf-hash-histogram is only implemented for llvm-readelf currently.
# RUN: yaml2obj --docnum=3 %s -o %t4.o # RUN: yaml2obj --docnum=3 %s -o %t4.o
# RUN: llvm-readelf --hash-table --elf-hash-histogram %t4.o 2>&1 \ # RUN: llvm-readelf --hash-table --elf-hash-histogram %t4.o 2>&1 \
# RUN: | FileCheck %s --check-prefix=SINGLE-WARN -DFILE=%t4.o --implicit-check-not="warning:" # RUN: | FileCheck %s --check-prefix=SINGLE-WARN -DFILE=%t4.o --implicit-check-not="warning:"
# SINGLE-WARN: warning: '[[FILE]]': hash table nchain (0) differs from symbol count derived from SHT_DYNSYM section header (1) # SINGLE-WARN: warning: '[[FILE]]': hash table nchain (0) differs from symbol count derived from SHT_DYNSYM section header (1)
# SINGLE-WARN-NEXT: HashTable { # SINGLE-WARN-NEXT: HashTable {
# SINGLE-WARN-NEXT: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8) # SINGLE-WARN-NEXT: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8)
# SINGLE-WARN-NEXT: } # SINGLE-WARN-NEXT: }

llvm/test/tools/llvm-readobj/ELF/loadname.test

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines Entries:
Value: 0x0000000000000000 Value: 0x0000000000000000
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
FileSize: [[PHDRFILESIZE]] FileSize: [[PHDRFILESIZE]]
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
## Check we do not crash when an object contains a DT_STRTAB entry whose address ## Check we do not crash when an object contains a DT_STRTAB entry whose address
## is past the end of the object. ## is past the end of the object.
## Note that we have to set p_filesz for PT_LOAD larger than DT_STRTAB value ## Note that we have to set p_filesz for PT_LOAD larger than DT_STRTAB value
## to trigger this particular warning. ## to trigger this particular warning.
# RUN: yaml2obj -DDTSTRTABVAL=0xFFFE -DPHDRFILESIZE=0xFFFF %s -o %t.err.1.o # RUN: yaml2obj -DDTSTRTABVAL=0xFFFE -DPHDRFILESIZE=0xFFFF %s -o %t.err.1.o
# RUN: llvm-readobj %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-LLVM # RUN: llvm-readobj %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-LLVM
# RUN: llvm-readelf --dynamic-table %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-GNU # RUN: llvm-readelf --dynamic-table %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-GNU
# BROKEN-OFFSET: warning: '[[FILE]]': Unable to parse DT_STRTAB: can't map virtual address 0xfffe to the segment with index 1: the segment ends at 0x10077, which is greater than the file size (0x228) # BROKEN-OFFSET: warning: '[[FILE]]': Unable to parse DT_STRTAB: can't map virtual address 0xfffe to the segment with index 1: the segment ends at 0x10077, which is greater than the file size (0x228)
# BROKEN-OFFSET: warning: '[[FILE]]': string table was not found # BROKEN-OFFSET: warning: '[[FILE]]': string table was not found
# BROKEN-OFFSET-LLVM: LoadName: <?> # BROKEN-OFFSET-LLVM: LoadName: <?>
# BROKEN-OFFSET-GNU: 0x000000000000000e (SONAME) Library soname: [<?>] # BROKEN-OFFSET-GNU: 0x000000000000000e (SONAME) Library soname: [<?>]

llvm/test/tools/llvm-readobj/ELF/malformed-pt-dynamic.test

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines - Name: .dynamic
Offset: 0x1000 Offset: 0x1000
ShOffset: [[OFFSET=<none>]] ShOffset: [[OFFSET=<none>]]
Entries: Entries:
- Tag: DT_NULL - Tag: DT_NULL
Value: 0 Value: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
FileSize: [[FILESIZE=<none>]] FileSize: [[FILESIZE=<none>]]
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
SectionHeaderTable: SectionHeaderTable:
NoHeaders: [[NOHEADERS=false]] NoHeaders: [[NOHEADERS=false]]

llvm/test/tools/llvm-readobj/ELF/needed-libs.test

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines Entries:
Value: 0x1111111 Value: 0x1111111
- Tag: DT_STRSZ - Tag: DT_STRSZ
Value: [[SIZE=0xD]] Value: [[SIZE=0xD]]
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x0 VAddr: 0x0
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic
## Check what we print when the dynamic string table is empty. ## Check what we print when the dynamic string table is empty.
# RUN: yaml2obj %s --docnum=2 -o %t2 # RUN: yaml2obj %s --docnum=2 -o %t2
# RUN: llvm-readobj --needed-libs %t2 2>&1 | \ # RUN: llvm-readobj --needed-libs %t2 2>&1 | \
# RUN: FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR # RUN: FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR
# RUN: llvm-readelf --needed-libs %t2 2>&1 | \ # RUN: llvm-readelf --needed-libs %t2 2>&1 | \
# RUN: FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR # RUN: FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR
Show All 24 Lines Entries:
Value: 1 Value: 1
- Tag: DT_NEEDED - Tag: DT_NEEDED
Value: 2 Value: 2
- Tag: DT_STRSZ - Tag: DT_STRSZ
Value: 0x0 Value: 0x0
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x0 VAddr: 0x0
Sections: FirstSec: .dynstr
- Section: .dynstr LastSec: .dynamic
- Section: .dynamic

llvm/test/tools/llvm-readobj/ELF/non-dynamic-in-pt-dynamic.test

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines - Name: .dynamic
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1001 Address: 0x1001
Entries: Entries:
- Tag: DT_BIND_NOW - Tag: DT_BIND_NOW
Value: 0x1 Value: 0x1
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0 Value: 0x0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .dynamic
- Section: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .text
- Section: .text LastSec: .dynamic
- Section: .dynamic
## In this case .text goes after .dynamic and we don't display any warnings, ## In this case .text goes after .dynamic and we don't display any warnings,
## though the content of the .text is used for dumping the dynamic table. ## though the content of the .text is used for dumping the dynamic table.
# RUN: yaml2obj --docnum=2 %s -o %t2.o # RUN: yaml2obj --docnum=2 %s -o %t2.o
# RUN: llvm-readobj --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=LLVM2 # RUN: llvm-readobj --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=LLVM2
# RUN: llvm-readelf --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=GNU2 # RUN: llvm-readelf --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=GNU2
Show All 28 Lines Entries:
Value: 0x2 Value: 0x2
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1100 Address: 0x1100
AddressAlign: 0x100 AddressAlign: 0x100
Content: "00000000000000000000000000000000" Content: "00000000000000000000000000000000"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
## In this case .text goes after .dynamic, but (PT_DYNAMIC segment size % dynamic entry size != 0) ## In this case .text goes after .dynamic, but (PT_DYNAMIC segment size % dynamic entry size != 0)
## and we have to use the information from the section header instead. ## and we have to use the information from the section header instead.
# RUN: yaml2obj --docnum=3 %s -o %t3.o # RUN: yaml2obj --docnum=3 %s -o %t3.o
# RUN: llvm-readobj --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,LLVM3 # RUN: llvm-readobj --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,LLVM3
# RUN: llvm-readelf --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,GNU3 # RUN: llvm-readelf --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,GNU3
Show All 29 Lines Entries:
Value: 0x0 Value: 0x0
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [SHF_ALLOC] Flags: [SHF_ALLOC]
Address: 0x1100 Address: 0x1100
AddressAlign: 0x100 AddressAlign: 0x100
Content: "00" Content: "00"
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .text
- Section: .text

llvm/test/tools/llvm-readobj/ELF/note-core-ntfile-bad.test

Show All 26 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Content: 0500000008000000454C4946434F5245000000000000000000000000 Content: 0500000008000000454C4946434F5245000000000000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo
# RUN: yaml2obj --docnum=2 %s -o %t2.o # RUN: yaml2obj --docnum=2 %s -o %t2.o
# RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck -DFILE=%t2.o %s --check-prefix=ERR-NULL-TERM # RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck -DFILE=%t2.o %s --check-prefix=ERR-NULL-TERM
# ERR-NULL-TERM: warning: '[[FILE]]': malformed note: not NUL terminated # ERR-NULL-TERM: warning: '[[FILE]]': malformed note: not NUL terminated
# .section ".note.foo", "a" # .section ".note.foo", "a"
# .align 4 # .align 4
# .long 5 /* namesz */ # .long 5 /* namesz */
Show All 15 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878 Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo
# RUN: yaml2obj --docnum=3 %s -o %t3.o # RUN: yaml2obj --docnum=3 %s -o %t3.o
# RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck -DFILE=%t3.o %s --check-prefix=ERR-FILE-COUNT # RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck -DFILE=%t3.o %s --check-prefix=ERR-FILE-COUNT
# ERR-FILE-COUNT: warning: '[[FILE]]': malformed note: too short for number of files # ERR-FILE-COUNT: warning: '[[FILE]]': malformed note: too short for number of files
# .section ".note.foo", "a" # .section ".note.foo", "a"
# .align 4 # .align 4
# .long 5 /* namesz */ # .long 5 /* namesz */
Show All 15 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00 Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo
# RUN: yaml2obj --docnum=4 %s -o %t4.o # RUN: yaml2obj --docnum=4 %s -o %t4.o
# RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck -DFILE=%t4.o %s --check-prefix=ERR-FILE-END-EARLY # RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck -DFILE=%t4.o %s --check-prefix=ERR-FILE-END-EARLY
# ERR-FILE-END-EARLY: warning: '[[FILE]]': malformed note: too few filenames # ERR-FILE-END-EARLY: warning: '[[FILE]]': malformed note: too few filenames
# .section ".note.foo", "a" # .section ".note.foo", "a"
# .align 4 # .align 4
# .long 5 /* namesz */ # .long 5 /* namesz */
Show All 18 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Content: 0500000044000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000078797A00 Content: 0500000044000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000078797A00
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo

llvm/test/tools/llvm-readobj/ELF/note-core-ntfile.test

Show All 39 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Content: 0500000080000000454C4946434F524500000000030000000000000000100000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000070000000000000008000000000000000900000000000002F706174682F746F2F612E6F7574002F706174682F746F2F6C6962632E736F005B737461636B5D00 Content: 0500000080000000454C4946434F524500000000030000000000000000100000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000070000000000000008000000000000000900000000000002F706174682F746F2F612E6F7574002F706174682F746F2F6C6962632E736F005B737461636B5D00
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo
# GNU: Displaying notes found # GNU: Displaying notes found
# GNU-NEXT: Owner Data size Description # GNU-NEXT: Owner Data size Description
# GNU-NEXT: CORE 0x00000080 NT_FILE (mapped files) # GNU-NEXT: CORE 0x00000080 NT_FILE (mapped files)
# GNU-NEXT: Page size: 4096 # GNU-NEXT: Page size: 4096
# GNU-NEXT: Start End Page Offset # GNU-NEXT: Start End Page Offset
# GNU-NEXT: 0x0000000000001000 0x0000000000002000 0x0000000000003000 # GNU-NEXT: 0x0000000000001000 0x0000000000002000 0x0000000000003000
# GNU-NEXT: /path/to/a.out # GNU-NEXT: /path/to/a.out
Show All 37 Lines

llvm/test/tools/llvm-readobj/ELF/note-core.test

Show First 20 Lines • Show All 265 Lines • ▼ Show 20 LinesFileHeader:
Type: ET_CORE Type: ET_CORE
Sections: Sections:
- Name: .note.foo - Name: .note.foo
Type: SHT_NOTE Type: SHT_NOTE
Notes: Notes:
- Name: CORE - Name: CORE
Type: [[TYPE]] Type: [[TYPE]]
ProgramHeaders: ProgramHeaders:
- Type: PT_NOTE - Type: PT_NOTE
Sections: FirstSec: .note.foo
- Section: .note.foo LastSec: .note.foo

llvm/test/tools/llvm-readobj/ELF/program-headers.test

Show First 20 Lines • Show All 439 Lines • ▼ Show 20 Lines - Name: .tls
Size: 0x1 Size: 0x1
- Name: .unused - Name: .unused
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_TLS ] Flags: [ SHF_ALLOC, SHF_TLS ]
Address: 0x5000 Address: 0x5000
Size: 0x1 Size: 0x1
ProgramHeaders: ProgramHeaders:
## Case 1: an arbitrary segment with sections. ## Case 1: an arbitrary segment with sections.
- Type: PT_PHDR - Type: PT_PHDR
Flags: [ PF_W ] Flags: [ PF_W ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 2: another segment with different sections. ## Case 2: another segment with different sections.
- Type: PT_PHDR - Type: PT_PHDR
Flags: [ PF_X ] Flags: [ PF_X ]
VAddr: 0x2000 VAddr: 0x2000
Sections: FirstSec: .bar.begin
- Section: .bar.begin LastSec: .bar.end
- Section: .bar.end
## Case 3: the PT_NULL segment. ## Case 3: the PT_NULL segment.
- Type: PT_NULL - Type: PT_NULL
Flags: [ PF_X ] Flags: [ PF_X ]
VAddr: 0x2000 VAddr: 0x2000
Sections: FirstSec: .bar.begin
- Section: .bar.begin LastSec: .bar.end
- Section: .bar.end
## Case 4: the PT_DYNAMIC segment. ## Case 4: the PT_DYNAMIC segment.
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_R, PF_W, PF_X ] Flags: [ PF_R, PF_W, PF_X ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 5: the PT_INTERP segment. ## Case 5: the PT_INTERP segment.
- Type: PT_INTERP - Type: PT_INTERP
Flags: [ PF_R, PF_W ] Flags: [ PF_R, PF_W ]
VAddr: 0x3000 VAddr: 0x3000
Sections: FirstSec: .interp
- Section: .interp LastSec: .interp
## Case 6: the PT_NOTE segment. ## Case 6: the PT_NOTE segment.
- Type: PT_NOTE - Type: PT_NOTE
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 7: the PT_SHLIB segment. ## Case 7: the PT_SHLIB segment.
- Type: PT_SHLIB - Type: PT_SHLIB
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.begin
## Case 8: the PT_TLS segment. ## Case 8: the PT_TLS segment.
- Type: PT_TLS - Type: PT_TLS
VAddr: 0x4000 VAddr: 0x4000
Sections: FirstSec: .tls
- Section: .tls LastSec: .tls
## Case 9: the PT_LOOS segment. ## Case 9: the PT_LOOS segment.
- Type: 0x60000000 ## PT_LOOS - Type: 0x60000000 ## PT_LOOS
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 10: the PT_GNU_EH_FRAME segment. ## Case 10: the PT_GNU_EH_FRAME segment.
- Type: PT_GNU_EH_FRAME - Type: PT_GNU_EH_FRAME
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 11: the PT_SUNW_UNWIND segment. ## Case 11: the PT_SUNW_UNWIND segment.
- Type: 0x6464e550 ## PT_SUNW_UNWIND - Type: 0x6464e550 ## PT_SUNW_UNWIND
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 12: the PT_GNU_STACK segment. ## Case 12: the PT_GNU_STACK segment.
- Type: PT_GNU_STACK - Type: PT_GNU_STACK
Sections:
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 13: the PT_GNU_RELRO segment. ## Case 13: the PT_GNU_RELRO segment.
- Type: PT_GNU_RELRO - Type: PT_GNU_RELRO
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 14: the PT_GNU_PROPERTY segment. ## Case 14: the PT_GNU_PROPERTY segment.
- Type: PT_GNU_PROPERTY - Type: PT_GNU_PROPERTY
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 15: the PT_OPENBSD_RANDOMIZE segment. ## Case 15: the PT_OPENBSD_RANDOMIZE segment.
- Type: 0x65a3dbe6 ## PT_OPENBSD_RANDOMIZE - Type: 0x65a3dbe6 ## PT_OPENBSD_RANDOMIZE
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 16: the PT_OPENBSD_WXNEEDED segment. ## Case 16: the PT_OPENBSD_WXNEEDED segment.
- Type: 0x65a3dbe7 ## PT_OPENBSD_WXNEEDED - Type: 0x65a3dbe7 ## PT_OPENBSD_WXNEEDED
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 17: the PT_OPENBSD_BOOTDATA segment. ## Case 17: the PT_OPENBSD_BOOTDATA segment.
- Type: 0x65a41be6 ## PT_OPENBSD_BOOTDATA - Type: 0x65a41be6 ## PT_OPENBSD_BOOTDATA
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 18: the PT_HIOS segment. ## Case 18: the PT_HIOS segment.
- Type: 0x6fffffff ## PT_HIOS - Type: 0x6fffffff ## PT_HIOS
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 19: the PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO segment. ## Case 19: the PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO segment.
- Type: 0x70000000 ## PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO - Type: 0x70000000 ## PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 20: the PT_ARM_EXIDX/PT_MIPS_RTPROC segment. ## Case 20: the PT_ARM_EXIDX/PT_MIPS_RTPROC segment.
- Type: 0x70000001 ## PT_ARM_EXIDX, PT_MIPS_RTPROC - Type: 0x70000001 ## PT_ARM_EXIDX, PT_MIPS_RTPROC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 20: the PT_MIPS_OPTIONS segment. ## Case 20: the PT_MIPS_OPTIONS segment.
- Type: 0x70000002 ## PT_MIPS_OPTIONS - Type: 0x70000002 ## PT_MIPS_OPTIONS
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 21: the PT_MIPS_ABIFLAGS segment. ## Case 21: the PT_MIPS_ABIFLAGS segment.
- Type: 0x70000003 ## PT_MIPS_ABIFLAGS - Type: 0x70000003 ## PT_MIPS_ABIFLAGS
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Case 22: the PT_HIPROC segment. ## Case 22: the PT_HIPROC segment.
- Type: 0x7fffffff ## PT_HIPROC - Type: 0x7fffffff ## PT_HIPROC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .foo.begin
- Section: .foo.begin LastSec: .foo.end
- Section: .foo.end
## Check how we dump ARM specific program headers. ## Check how we dump ARM specific program headers.
# RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_ARM %s -o %tarm.elf # RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_ARM %s -o %tarm.elf
# RUN: llvm-readelf --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-GNU # RUN: llvm-readelf --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-GNU
# RUN: llvm-readobj --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-LLVM # RUN: llvm-readobj --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-LLVM
# ARM-GNU: <unknown>: 0x70000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1 # ARM-GNU: <unknown>: 0x70000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
# ARM-GNU-NEXT: EXIDX 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1 # ARM-GNU-NEXT: EXIDX 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 LinesFileHeader:
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
EPhEntSize: [[PHENTSIZE=<none>]] EPhEntSize: [[PHENTSIZE=<none>]]
EPhOff: [[PHOFF=<none>]] EPhOff: [[PHOFF=<none>]]
Sections: Sections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
ProgramHeaders: ProgramHeaders:
- Type: PT_PHDR - Type: PT_PHDR
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
## Case B: the value of the e_phoff field is invalid. ## Case B: the value of the e_phoff field is invalid.
## Check that we do not report a warning when the program header table ends right before the end of the file. ## Check that we do not report a warning when the program header table ends right before the end of the file.
## 0x160 + size of headers (56) == file size. ## 0x160 + size of headers (56) == file size.
# RUN: yaml2obj --docnum=3 -DPHOFF=0x160 %s -o %t.phdr.no.err2 # RUN: yaml2obj --docnum=3 -DPHOFF=0x160 %s -o %t.phdr.no.err2
# RUN: llvm-readelf %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning: # RUN: llvm-readelf %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning:
# RUN: llvm-readobj %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning: # RUN: llvm-readobj %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning:
Show All 26 Lines

llvm/test/tools/llvm-readobj/ELF/reloc-negative-addend-no-sym.test

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines - Name: .rela.dyn
Relocations: Relocations:
- Offset: 8 - Offset: 8
Type: R_X86_64_NONE Type: R_X86_64_NONE
Addend: -1 Addend: -1
DynamicSymbols: DynamicSymbols:
- Name: force_dynsym - Name: force_dynsym
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .rela.dyn
- Section: .rela.dyn
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines - Value: 0x123
Section: .text Section: .text
Binding: STB_GLOBAL Binding: STB_GLOBAL
- Type: STT_SECTION - Type: STT_SECTION
Index: 0 Index: 0
- Value: 0x0 - Value: 0x0
Section: .text Section: .text
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .rela.dyn
- Section: .rela.dyn
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/llvm-readobj/ELF/unwind.test

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines - Name: myfunc
Section: .text Section: .text
Value: 0x0000000000400000 Value: 0x0000000000400000
Binding: STB_GLOBAL Binding: STB_GLOBAL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x00400000 VAddr: 0x00400000
PAddr: 0x00400000 PAddr: 0x00400000
Sections: FirstSec: .text
- Section: .text LastSec: .text
- Type: PT_GNU_EH_FRAME - Type: PT_GNU_EH_FRAME
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x004013C0 VAddr: 0x004013C0
PAddr: 0x004013C0 PAddr: 0x004013C0
MemSize: [[MEMSIZE]] MemSize: [[MEMSIZE]]
FileSize: [[FILESIZE]] FileSize: [[FILESIZE]]
Sections: FirstSec: .eh_frame_hdr
- Section: .eh_frame_hdr LastSec: .eh_frame_hdr
## Document we report a error when the memory size of the PT_GNU_EH_FRAME does not match its file size. ## Document we report a error when the memory size of the PT_GNU_EH_FRAME does not match its file size.
## TODO: we want to report a warning and continue dumping instead. ## TODO: we want to report a warning and continue dumping instead.
# RUN: yaml2obj --docnum=1 %s -DMEMSIZE=0x3b -DFILESIZE=0x3c -o %t1.size.mismatch # RUN: yaml2obj --docnum=1 %s -DMEMSIZE=0x3b -DFILESIZE=0x3c -o %t1.size.mismatch
# RUN: not llvm-readobj --unwind %t1.size.mismatch 2>&1 | \ # RUN: not llvm-readobj --unwind %t1.size.mismatch 2>&1 | \
# RUN: FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH # RUN: FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH
# RUN: not llvm-readelf --unwind %t1.size.mismatch 2>&1 | \ # RUN: not llvm-readelf --unwind %t1.size.mismatch 2>&1 | \
# RUN: FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH # RUN: FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
# BROKEN-CONTENT-NEXT: error: '[[FILE]]': program header [index 0] has a p_offset ([[OFFSET]]) + p_filesz ([[SIZE]]) that is greater than the file size (0xe0) # BROKEN-CONTENT-NEXT: error: '[[FILE]]': program header [index 0] has a p_offset ([[OFFSET]]) + p_filesz ([[SIZE]]) that is greater than the file size (0xe0)
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS[[BITS]] Class: ELFCLASS[[BITS]]
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
ProgramHeaders: ProgramHeaders:
- Type: PT_GNU_EH_FRAME - Type: PT_GNU_EH_FRAME
MemSize: [[SIZE]] MemSize: [[SIZE]]
FileSize: [[SIZE]] FileSize: [[SIZE]]
Offset: [[OFFSET]] Offset: [[OFFSET]]
Sections: []
## Case B: test we report an error when the file size of the PT_GNU_EH_FRAME ## Case B: test we report an error when the file size of the PT_GNU_EH_FRAME
## is invalid (goes past the end of the file). ## is invalid (goes past the end of the file).
# RUN: yaml2obj --docnum=4 %s -o %t6 -DOFFSET=0x100 -DSIZE=0xffff0000 -DBITS=32 # RUN: yaml2obj --docnum=4 %s -o %t6 -DOFFSET=0x100 -DSIZE=0xffff0000 -DBITS=32
# RUN: not llvm-readobj --unwind %t6 2>&1 \ # RUN: not llvm-readobj --unwind %t6 2>&1 \
# RUN: | FileCheck %s -DFILE=%t6 --check-prefix=BROKEN-CONTENT -DOFFSET=0x100 -DSIZE=0xffff0000 # RUN: | FileCheck %s -DFILE=%t6 --check-prefix=BROKEN-CONTENT -DOFFSET=0x100 -DSIZE=0xffff0000
## Case C: test we report an error when the offset + the file size of the PT_GNU_EH_FRAME is so large a ## Case C: test we report an error when the offset + the file size of the PT_GNU_EH_FRAME is so large a
Show All 20 Lines

llvm/test/tools/llvm-xray/ARM/extract-instrmap.test

Show All 11 Lines
FileHeader: FileHeader:
Class: ELFCLASS32 Class: ELFCLASS32
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
Machine: EM_ARM Machine: EM_ARM
Flags: [ EF_ARM_SOFT_FLOAT, EF_ARM_EABI_VER5 ] Flags: [ EF_ARM_SOFT_FLOAT, EF_ARM_EABI_VER5 ]
Entry: 0x00000000000012B0 Entry: 0x00000000000012B0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .rel.dyn
- Section: .rel.dyn LastSec: .rel.dyn
Align: 0x0000000000001000 Align: 0x0000000000001000
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .text
- Section: .text LastSec: .text
VAddr: 0x00000000000012B0 VAddr: 0x00000000000012B0
Align: 0x0000000000001000 Align: 0x0000000000001000
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: xray_instr_map
- Section: xray_instr_map LastSec: xray_fn_idx
- Section: xray_fn_idx
VAddr: 0x00000000000033CC VAddr: 0x00000000000033CC
Align: 0x0000000000001000 Align: 0x0000000000001000
Sections: Sections:
- Name: .rel.dyn - Name: .rel.dyn
Type: SHT_REL Type: SHT_REL
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x0000000000000200 Address: 0x0000000000000200
Link: .dynsym Link: .dynsym
AddressAlign: 0x0000000000000004 AddressAlign: 0x0000000000000004
Relocations: Relocations:
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/tools/obj2yaml/ELF/program-headers.yaml

Show All 31 Lines
# SEGMENT-MAPPING-NEXT: 08 .gnu.hash {{$}} # SEGMENT-MAPPING-NEXT: 08 .gnu.hash {{$}}
# SEGMENT-MAPPING-NEXT: None .symtab .strtab .shstrtab {{$}} # SEGMENT-MAPPING-NEXT: None .symtab .strtab .shstrtab {{$}}
## Check that obj2yaml produced a correct program headers description. ## Check that obj2yaml produced a correct program headers description.
# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=YAML # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=YAML
# YAML: ProgramHeaders: # YAML: ProgramHeaders:
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .hash
# YAML-NEXT: - Section: .hash # YAML-NEXT: LastSec: .dynstr
# YAML-NEXT: - Section: .gnu.hash
# YAML-NEXT: - Section: .dynsym
# YAML-NEXT: - Section: .dynstr
# YAML-NEXT: Align: 0x0000000000001000 # YAML-NEXT: Align: 0x0000000000001000
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_X, PF_R ] # YAML-NEXT: Flags: [ PF_X, PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .foo
# YAML-NEXT: - Section: .foo # YAML-NEXT: LastSec: .zed
# YAML-NEXT: - Section: .zed
# YAML-NEXT: VAddr: 0x0000000000001000 # YAML-NEXT: VAddr: 0x0000000000001000
# YAML-NEXT: Align: 0x0000000000001000 # YAML-NEXT: Align: 0x0000000000001000
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: '.foo (1)'
# YAML-NEXT: - Section: '.foo (1)' # YAML-NEXT: LastSec: .baz
# YAML-NEXT: - Section: .baz
# YAML-NEXT: VAddr: 0x0000000000002000 # YAML-NEXT: VAddr: 0x0000000000002000
# YAML-NEXT: Align: 0x0000000000001000 # YAML-NEXT: Align: 0x0000000000001000
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_W, PF_R ] # YAML-NEXT: Flags: [ PF_W, PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .dynamic
# YAML-NEXT: - Section: .dynamic # YAML-NEXT: LastSec: .dynamic.tail
# YAML-NEXT: - Section: .dynamic.tail
# YAML-NEXT: VAddr: 0x0000000000003EF0 # YAML-NEXT: VAddr: 0x0000000000003EF0
# YAML-NEXT: Align: 0x0000000000001000 # YAML-NEXT: Align: 0x0000000000001000
# YAML-NEXT: - Type: PT_DYNAMIC # YAML-NEXT: - Type: PT_DYNAMIC
# YAML-NEXT: Flags: [ PF_W, PF_R ] # YAML-NEXT: Flags: [ PF_W, PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .dynamic
# YAML-NEXT: - Section: .dynamic # YAML-NEXT: LastSec: .dynamic
# YAML-NEXT: VAddr: 0x0000000000003EF0 # YAML-NEXT: VAddr: 0x0000000000003EF0
# YAML-NEXT: Align: 0x0000000000000008 # YAML-NEXT: Align: 0x0000000000000008
# YAML-NEXT: - Type: PT_GNU_RELRO # YAML-NEXT: - Type: PT_GNU_RELRO
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .dynamic
# YAML-NEXT: - Section: .dynamic # YAML-NEXT: LastSec: .dynamic
# YAML-NEXT: VAddr: 0x0000000000003EF0 # YAML-NEXT: VAddr: 0x0000000000003EF0
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: VAddr: 0x0000000000004000 # YAML-NEXT: VAddr: 0x0000000000004000
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .gnu.hash
# YAML-NEXT: - Section: .gnu.hash # YAML-NEXT: LastSec: .gnu.hash
# YAML-NEXT: VAddr: 0x00000000000001A0 # YAML-NEXT: VAddr: 0x00000000000001A0
# YAML-NEXT: - Type: PT_LOAD # YAML-NEXT: - Type: PT_LOAD
# YAML-NEXT: Flags: [ PF_R ] # YAML-NEXT: Flags: [ PF_R ]
# YAML-NEXT: Sections: # YAML-NEXT: FirstSec: .gnu.hash
# YAML-NEXT: - Section: .gnu.hash # YAML-NEXT: LastSec: .gnu.hash
# YAML-NEXT: VAddr: 0x00000000000001A0 # YAML-NEXT: VAddr: 0x00000000000001A0
# YAML-NEXT: Sections: # YAML-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
ProgramHeaders: ProgramHeaders:
## Check we can create a PT_LOAD with arbitrary (we used .hash, .gnu.hash) ## Check we can create a PT_LOAD with arbitrary (we used .hash, .gnu.hash)
## and implicit sections (we use .dynsym, .dynstr). It also checks that the ## and implicit sections (we use .dynsym, .dynstr). It also checks that the
## SHT_NULL section at index 0 is not included in the segment. ## SHT_NULL section at index 0 is not included in the segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .hash
- Section: .hash LastSec: .dynstr
- Section: .gnu.hash
- Section: .dynsym
- Section: .dynstr
Align: 0x1000 Align: 0x1000
Offset: 0x0 Offset: 0x0
## Check we can create a PT_LOAD with a different set of properties and sections. ## Check we can create a PT_LOAD with a different set of properties and sections.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .foo
- Section: .foo LastSec: .zed
- Section: .zed
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
## Create a PT_LOAD to demonstate we are able to refer to output sections with the same name. ## Create a PT_LOAD to demonstate we are able to refer to output sections with the same name.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: '.foo (1)'
- Section: '.foo (1)' LastSec: .baz
- Section: .baz
VAddr: 0x2000 VAddr: 0x2000
Align: 0x1000 Align: 0x1000
## Show we can create a writeable PT_LOAD segment and put an arbitrary section into it. ## Show we can create a writeable PT_LOAD segment and put an arbitrary section into it.
## Here we test both regular (SHT_PROGBITS) and a special section (SHT_DYNAMIC). ## Here we test both regular (SHT_PROGBITS) and a special section (SHT_DYNAMIC).
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic.tail
- Section: .dynamic.tail
VAddr: 0x3EF0 VAddr: 0x3EF0
Align: 0x1000 Align: 0x1000
## Show we can create a nested dynamic segment and put a section into it. ## Show we can create a nested dynamic segment and put a section into it.
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
VAddr: 0x3EF0 VAddr: 0x3EF0
Align: 0x8 Align: 0x8
## Show we can create a relro segment and put a section into it. ## Show we can create a relro segment and put a section into it.
## We used .dynamic here and in tests above to demonstrate that ## We used .dynamic here and in tests above to demonstrate that
## we can place a section in any number of segments. ## we can place a section in any number of segments.
## Also, we explicitly set the "Align" property to 1 to demonstate ## Also, we explicitly set the "Align" property to 1 to demonstate
## that we do not dump it, because it is the default alignment ## that we do not dump it, because it is the default alignment
## value set by yaml2obj. ## value set by yaml2obj.
- Type: PT_GNU_RELRO - Type: PT_GNU_RELRO
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
VAddr: 0x3EF0 VAddr: 0x3EF0
Align: 0x1 Align: 0x1
## Show we can dump a standalone empty segment. ## Show we can dump a standalone empty segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: [ ]
VAddr: 0x4000 VAddr: 0x4000
Align: 0x1 Align: 0x1
## ELF specification says that loadable segment entries in the ## ELF specification says that loadable segment entries in the
## program header are sorted by virtual address. ## program header are sorted by virtual address.
## Show we can dump an out of order segment. ## Show we can dump an out of order segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .gnu.hash
VAddr: 0x1A0 VAddr: 0x1A0
Align: 0x1 Align: 0x1
## Test we are able to dump duplicated segments. ## Test we are able to dump duplicated segments.
## We use a segment that is the same as the previous one for this. ## We use a segment that is the same as the previous one for this.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .gnu.hash
- Section: .gnu.hash LastSec: .gnu.hash
VAddr: 0x1A0 VAddr: 0x1A0
Align: 0x1 Align: 0x1
Sections: Sections:
- Name: .hash - Name: .hash
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Address: 0x190 Address: 0x190
Size: 0x10 Size: 0x10
- Name: .gnu.hash - Name: .gnu.hash
Type: SHT_PROGBITS Type: SHT_PROGBITS
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
## Part II. More specific tests. ## Part II. More specific tests.
## Check we are able to dump segments that are empty or ## Check we are able to dump segments that are empty or
## contain empty sections. ## contain empty sections.
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=EMPTY # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=EMPTY
# EMPTY: - Type: PT_LOAD # EMPTY: - Type: PT_LOAD
# EMPTY-NEXT: Flags: [ PF_W, PF_R ] # EMPTY-NEXT: Flags: [ PF_W, PF_R ]
# EMPTY-NEXT: Sections: # EMPTY-NEXT: FirstSec: .empty.tls.start
# EMPTY-NEXT: - Section: .empty.tls.start # EMPTY-NEXT: LastSec: .empty.tls.end
# EMPTY-NEXT: - Section: .section.1
# EMPTY-NEXT: - Section: .empty.tls.middle
# EMPTY-NEXT: - Section: .section.2
# EMPTY-NEXT: - Section: .empty.tls.end
# EMPTY-NEXT: VAddr: 0x0000000000001000 # EMPTY-NEXT: VAddr: 0x0000000000001000
# EMPTY-NEXT: Align: 0x0000000000001000 # EMPTY-NEXT: Align: 0x0000000000001000
# EMPTY-NEXT: - Type: PT_TLS # EMPTY-NEXT: - Type: PT_TLS
# EMPTY-NEXT: Flags: [ PF_W, PF_R ] # EMPTY-NEXT: Flags: [ PF_W, PF_R ]
# EMPTY-NEXT: Sections: # EMPTY-NEXT: FirstSec: .empty.tls.start
# EMPTY-NEXT: - Section: .empty.tls.start # EMPTY-NEXT: LastSec: .empty.tls.start
# EMPTY-NEXT: VAddr: 0x0000000000001000 # EMPTY-NEXT: VAddr: 0x0000000000001000
# EMPTY-NEXT: - Type: PT_TLS # EMPTY-NEXT: - Type: PT_TLS
# EMPTY-NEXT: Flags: [ PF_W, PF_R ] # EMPTY-NEXT: Flags: [ PF_W, PF_R ]
# EMPTY-NEXT: Sections: # EMPTY-NEXT: FirstSec: .empty.tls.middle
# EMPTY-NEXT: - Section: .empty.tls.middle # EMPTY-NEXT: LastSec: .empty.tls.middle
# EMPTY-NEXT: VAddr: 0x0000000000001100 # EMPTY-NEXT: VAddr: 0x0000000000001100
# EMPTY-NEXT: - Type: PT_TLS # EMPTY-NEXT: - Type: PT_TLS
# EMPTY-NEXT: Flags: [ PF_W, PF_R ] # EMPTY-NEXT: Flags: [ PF_W, PF_R ]
# EMPTY-NEXT: Sections: # EMPTY-NEXT: FirstSec: .empty.tls.end
# EMPTY-NEXT: - Section: .empty.tls.end # EMPTY-NEXT: LastSec: .empty.tls.end
# EMPTY-NEXT: VAddr: 0x0000000000001200 # EMPTY-NEXT: VAddr: 0x0000000000001200
# EMPTY-NEXT: Sections: # EMPTY-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .empty.tls.start
- Section: .empty.tls.start LastSec: .empty.tls.end
- Section: .section.1
- Section: .empty.tls.middle
- Section: .section.2
- Section: .empty.tls.end
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
- Type: PT_TLS - Type: PT_TLS
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .empty.tls.start
- Section: .empty.tls.start LastSec: .empty.tls.start
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1 Align: 0x1
- Type: PT_TLS - Type: PT_TLS
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .empty.tls.middle
- Section: .empty.tls.middle LastSec: .empty.tls.middle
VAddr: 0x1100 VAddr: 0x1100
Align: 0x1 Align: 0x1
- Type: PT_TLS - Type: PT_TLS
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .empty.tls.end
- Section: .empty.tls.end LastSec: .empty.tls.end
VAddr: 0x1200 VAddr: 0x1200
Align: 0x1 Align: 0x1
Sections: Sections:
- Name: .empty.tls.start - Name: .empty.tls.start
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_TLS ] Flags: [ SHF_ALLOC, SHF_TLS ]
Size: 0x0 Size: 0x0
Address: 0x1000 Address: 0x1000
- Name: .section.1 - Name: .section.1
Type: SHT_PROGBITS Type: SHT_PROGBITS
Show All 20 Lines
## As a misaligned p_offset value we use (`.foo` section offset - 1). ## As a misaligned p_offset value we use (`.foo` section offset - 1).
# MISALIGNED-READELF: [Nr] Name Type Address Off # MISALIGNED-READELF: [Nr] Name Type Address Off
# MISALIGNED-READELF: [ 1] .foo PROGBITS 0000000000001000 000078 # MISALIGNED-READELF: [ 1] .foo PROGBITS 0000000000001000 000078
# MISALIGNED-READELF: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align # MISALIGNED-READELF: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
# MISALIGNED-READELF-NEXT: LOAD 0x000077 0x0000000000001000 0x0000000000001000 0x000078 0x000078 R 0x1000 # MISALIGNED-READELF-NEXT: LOAD 0x000077 0x0000000000001000 0x0000000000001000 0x000078 0x000078 R 0x1000
# MISALIGNED-YAML: ProgramHeaders: # MISALIGNED-YAML: ProgramHeaders:
# MISALIGNED-YAML-NEXT: - Type: PT_LOAD # MISALIGNED-YAML-NEXT: - Type: PT_LOAD
# MISALIGNED-YAML-NEXT: Flags: [ PF_R ] # MISALIGNED-YAML-NEXT: Flags: [ PF_R ]
# MISALIGNED-YAML-NEXT: Sections: # MISALIGNED-YAML-NEXT: FirstSec: .foo
# MISALIGNED-YAML-NEXT: - Section: .foo # MISALIGNED-YAML-NEXT: LastSec: .foo
# MISALIGNED-YAML-NEXT: VAddr: 0x0000000000001000 # MISALIGNED-YAML-NEXT: VAddr: 0x0000000000001000
# MISALIGNED-YAML-NEXT: Align: 0x0000000000001000 # MISALIGNED-YAML-NEXT: Align: 0x0000000000001000
# MISALIGNED-YAML-NEXT: Sections: # MISALIGNED-YAML-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
VAddr: 0x1000 VAddr: 0x1000
Align: 0x1000 Align: 0x1000
Offset: 0x000077 Offset: 0x000077
Sections: Sections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x77 Size: 0x77
Address: 0x1000 Address: 0x1000
## Test we include non-allocatable sections in segments. ## Test we include non-allocatable sections in segments.
## We also document that SHT_NULL sections are not considered to be inside a segment. ## We also document that SHT_NULL sections are not considered to be inside a segment.
jhendersonUnsubmitted
Done
ReplyInline Actions

This comment probably needs updating.

jhenderson: This comment probably needs updating.
grimarAuthorUnsubmitted
Done
ReplyInline Actions

I've updated the test itself instead.

grimar: I've updated the test itself instead.
# RUN: yaml2obj --docnum=4 %s -o %t4 # RUN: yaml2obj --docnum=4 %s -o %t4
# RUN: obj2yaml %t4 | FileCheck %s --check-prefix=NON-ALLOC # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=NON-ALLOC
# NON-ALLOC: ProgramHeaders: # NON-ALLOC: ProgramHeaders:
# NON-ALLOC-NEXT: - Type: PT_LOAD # NON-ALLOC-NEXT: - Type: PT_LOAD
# NON-ALLOC-NEXT: Flags: [ PF_R ] # NON-ALLOC-NEXT: Flags: [ PF_R ]
# NON-ALLOC-NEXT: Sections: # NON-ALLOC-NEXT: FirstSec: .alloc.1
# NON-ALLOC-NEXT: - Section: .alloc.1 # NON-ALLOC-NEXT: LastSec: .non-alloc.1
# NON-ALLOC-NEXT: - Section: .non-alloc.1 # NON-ALLOC-NEXT: - Type: PT_LOAD
# NON-ALLOC-NEXT: - Section: .alloc.2 # NON-ALLOC-NEXT: Flags: [ PF_R ]
# NON-ALLOC-NEXT: VAddr: 0x0000000000001000 # NON-ALLOC-NEXT: FirstSec: .alloc.1
# NON-ALLOC-NEXT: LastSec: .non-alloc.1
# NON-ALLOC-NEXT: - Type: PT_LOAD
# NON-ALLOC-NEXT: Flags: [ PF_R ]
# NON-ALLOC-NEXT: FirstSec: .alloc.2
# NON-ALLOC-NEXT: LastSec: .alloc.2
# NON-ALLOC-NEXT: - Type: PT_LOAD
# NON-ALLOC-NEXT: Flags: [ PF_R ]
# NON-ALLOC-NEXT: FirstSec: .alloc.1
# NON-ALLOC-NEXT: LastSec: .alloc.2
# NON-ALLOC-NEXT: Sections: # NON-ALLOC-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .alloc.1
- Section: .alloc.1 LastSec: .non-alloc.1
- Section: .alloc.2 - Type: PT_LOAD
VAddr: 0x1000 Flags: [ PF_R ]
FirstSec: .alloc.1
LastSec: .non-alloc.2
- Type: PT_LOAD
Flags: [ PF_R ]
FirstSec: .non-alloc.2
LastSec: .alloc.2
- Type: PT_LOAD
Flags: [ PF_R ]
FirstSec: .alloc.1
LastSec: .alloc.2
Sections: Sections:
- Name: .alloc.1 - Name: .alloc.1
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x100 Size: 0x100
Address: 0x1000 Address: 0x1000
- Name: .non-alloc.1 - Name: .non-alloc.1
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ ] Flags: [ ]
Size: 0x10 Size: 0x10
- Name: .non-alloc.2 - Name: .non-alloc.2
Type: SHT_NULL Type: SHT_NULL
Flags: [ ] Flags: [ ]
jhendersonUnsubmitted
Done
ReplyInline Actions

We probably need a case where .non-alloc.2 would be the LastSec too.

jhenderson: We probably need a case where .non-alloc.2 would be the `LastSec` too.
Size: 0x10 Size: 0x10
- Name: .alloc.2 - Name: .alloc.2
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
## Check how we dump segments which contain SHT_NOBITS sections. ## Check how we dump segments which contain SHT_NOBITS sections.
# RUN: yaml2obj --docnum=5 %s -o %t5 # RUN: yaml2obj --docnum=5 %s -o %t5
# RUN: obj2yaml %t5 | FileCheck %s --check-prefix=NOBITS # RUN: obj2yaml %t5 | FileCheck %s --check-prefix=NOBITS
# NOBITS: ProgramHeaders: # NOBITS: ProgramHeaders:
# NOBITS-NEXT: - Type: PT_LOAD # NOBITS-NEXT: - Type: PT_LOAD
# NOBITS-NEXT: Flags: [ PF_W, PF_R ] # NOBITS-NEXT: Flags: [ PF_W, PF_R ]
# NOBITS-NEXT: Sections: # NOBITS-NEXT: FirstSec: .bss
# NOBITS-NEXT: - Section: .bss # NOBITS-NEXT: LastSec: .bss
# NOBITS-NEXT: - Type: PT_LOAD # NOBITS-NEXT: - Type: PT_LOAD
# NOBITS-NEXT: Flags: [ PF_W, PF_R ] # NOBITS-NEXT: Flags: [ PF_W, PF_R ]
# NOBITS-NEXT: Sections: # NOBITS-NEXT: FirstSec: .data.1
# NOBITS-NEXT: - Section: .data.1 # NOBITS-NEXT: LastSec: .bss
# NOBITS-NEXT: - Section: .bss
# NOBITS-NEXT: - Type: PT_LOAD # NOBITS-NEXT: - Type: PT_LOAD
# NOBITS-NEXT: Flags: [ PF_W, PF_R ] # NOBITS-NEXT: Flags: [ PF_W, PF_R ]
# NOBITS-NEXT: Sections: # NOBITS-NEXT: FirstSec: .data.1
# NOBITS-NEXT: - Section: .data.1 # NOBITS-NEXT: LastSec: .data.2
# NOBITS-NEXT: - Section: .bss
# NOBITS-NEXT: - Section: .data.2
# NOBITS-NEXT: - Type: PT_LOAD # NOBITS-NEXT: - Type: PT_LOAD
# NOBITS-NEXT: Flags: [ PF_W, PF_R ] # NOBITS-NEXT: Flags: [ PF_W, PF_R ]
# NOBITS-NEXT: Sections: # NOBITS-NEXT: FirstSec: .bss
# NOBITS-NEXT: - Section: .bss # NOBITS-NEXT: LastSec: .data.2
# NOBITS-NEXT: - Section: .data.2
# NOBITS-NEXT: - Type: PT_LOAD # NOBITS-NEXT: - Type: PT_LOAD
# NOBITS-NEXT: Flags: [ PF_W, PF_R ] # NOBITS-NEXT: Flags: [ PF_W, PF_R ]
# NOBITS-NEXT: Sections: # NOBITS-NEXT: FirstSec: .foo.bss
# NOBITS-NEXT: - Section: .foo.bss # NOBITS-NEXT: LastSec: .bar.bss
# NOBITS-NEXT: - Section: .bar.bss
# NOBITS-NEXT: VAddr: 0x0000000200000000 # NOBITS-NEXT: VAddr: 0x0000000200000000
# NOBITS-NEXT: Sections: # NOBITS-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
ProgramHeaders: ProgramHeaders:
## Case 1: the segment contains a single SHT_NOBITS section. ## Case 1: the segment contains a single SHT_NOBITS section.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .bss
- Section: .bss LastSec: .bss
## Case 2: the SHT_NOBITS section is the last section in the segment. ## Case 2: the SHT_NOBITS section is the last section in the segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .data.1
- Section: .data.1 LastSec: .bss
- Section: .bss
## Case 3: the SHT_NOBITS section is in the middle of the segment. ## Case 3: the SHT_NOBITS section is in the middle of the segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .data.1
- Section: .data.1 LastSec: .data.2
- Section: .bss
- Section: .data.2
## Case 4: the SHT_NOBITS section is the first section in the segment. ## Case 4: the SHT_NOBITS section is the first section in the segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .bss
- Section: .bss LastSec: .data.2
- Section: .data.2
## Case 5: another two SHT_NOBITS sections in a different segment. ## Case 5: another two SHT_NOBITS sections in a different segment.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .foo.bss
- Section: .foo.bss LastSec: .bar.bss
- Section: .bar.bss
VAddr: 0x200000000 VAddr: 0x200000000
Sections: Sections:
- Name: .data.1 - Name: .data.1
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_WRITE, SHF_ALLOC ] Flags: [ SHF_WRITE, SHF_ALLOC ]
## Use an arbitrary address and size. ## Use an arbitrary address and size.
Address: 0x1000 Address: 0x1000
Size: 0x1 Size: 0x1
- Name: .bss - Name: .bss
Show All 21 Lines
## the previous section. ## the previous section.
Size: 0x20 Size: 0x20
## Check that we require sections in a program header ## Check that we require sections in a program header
## declaration to be sorted by their offsets. ## declaration to be sorted by their offsets.
# RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | \ # RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | \
# RUN: FileCheck %s --check-prefix=UNSORTED --implicit-check-not="error:" # RUN: FileCheck %s --check-prefix=UNSORTED --implicit-check-not="error:"
# UNSORTED: error: sections in the program header with index 1 are not sorted by their file offset # UNSORTED: error: program header with index 0: the section index of .bar is greater than the index of .foo
# UNSORTED-NEXT: error: sections in the program header with index 3 are not sorted by their file offset # UNSORTED-NEXT: error: sections in the program header with index 3 are not sorted by their file offset
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
ProgramHeaders: ProgramHeaders:
## Case 1: the .bar section is placed after the .foo section in the file. ## 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. ## Check we report an error about the violation of the order.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .bar
- Section: .bar LastSec: .foo
- Section: .foo
VAddr: 0x1000 VAddr: 0x1000
## There is nothing wrong with this segment. We have it to show that ## There is nothing wrong with this segment. We have it to show that
## we report correct program header indices in error messages. ## we report correct program header indices in error messages.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .foo
- Section: .foo LastSec: .bar
- Section: .bar
VAddr: 0x1000 VAddr: 0x1000
## Case 2: the .bar section is placed before the .zed section in the file, ## Case 2: the .bar section is placed before the .zed section in the file,
## but the sh_offset of .zed is less than the sh_offset of ## but the sh_offset of .zed is less than the sh_offset of
## the .bar section because of the "ShOffset" property. ## the .bar section because of the "ShOffset" property.
## Document we report an error for such a case. ## Document we report an error for such a case.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .bar
- Section: .bar LastSec: .zed
- Section: .zed
VAddr: 0x1001 VAddr: 0x1001
Sections: Sections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
Address: 0x1000 Address: 0x1000
- Name: .bar - Name: .bar
Type: SHT_PROGBITS Type: SHT_PROGBITS
Show All 22 Lines
# ZERO-SIZE-MAPPING-NEXT: [ 2] .empty.bar1 PROGBITS 0000000000002000 000078 000000 # ZERO-SIZE-MAPPING-NEXT: [ 2] .empty.bar1 PROGBITS 0000000000002000 000078 000000
# ZERO-SIZE-MAPPING-NEXT: [ 3] .bar PROGBITS 0000000000002000 000078 000001 # ZERO-SIZE-MAPPING-NEXT: [ 3] .bar PROGBITS 0000000000002000 000078 000001
# ZERO-SIZE-MAPPING-NEXT: [ 4] .empty.bar2 PROGBITS 0000000000002001 000079 000000 # ZERO-SIZE-MAPPING-NEXT: [ 4] .empty.bar2 PROGBITS 0000000000002001 000079 000000
# ZERO-SIZE-MAPPING-NEXT: [ 5] .empty.zed PROGBITS 0000000000003000 000079 000000 # ZERO-SIZE-MAPPING-NEXT: [ 5] .empty.zed PROGBITS 0000000000003000 000079 000000
# RUN: obj2yaml %t7 | FileCheck %s --check-prefix=ZERO-SIZE # RUN: obj2yaml %t7 | FileCheck %s --check-prefix=ZERO-SIZE
# ZERO-SIZE: ProgramHeaders: # ZERO-SIZE: ProgramHeaders:
# ZERO-SIZE-NEXT: - Type: PT_LOAD # ZERO-SIZE-NEXT: - Type: PT_LOAD
# ZERO-SIZE-NEXT: Flags: [ PF_W, PF_R ] # ZERO-SIZE-NEXT: Flags: [ PF_W, PF_R ]
# ZERO-SIZE-NEXT: Sections: # ZERO-SIZE-NEXT: FirstSec: .empty.bar1
# ZERO-SIZE-NEXT: - Section: .empty.bar1 # ZERO-SIZE-NEXT: LastSec: .empty.bar2
# ZERO-SIZE-NEXT: - Section: .bar
# ZERO-SIZE-NEXT: - Section: .empty.bar2
# ZERO-SIZE-NEXT: VAddr: 0x0000000000002000 # ZERO-SIZE-NEXT: VAddr: 0x0000000000002000
# ZERO-SIZE-NEXT: Sections: # ZERO-SIZE-NEXT: Sections:
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
Sections: FirstSec: .bar
- Section: .bar LastSec: .bar
VAddr: 0x2000 VAddr: 0x2000
Sections: Sections:
- Name: .empty.foo - Name: .empty.foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x1000 Address: 0x1000
- Name: .empty.bar1 - Name: .empty.bar1
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Show All 15 Lines
## Check how we dump a segment when we have sections that are outside of the virtual ## Check how we dump a segment when we have sections that are outside of the virtual
## address space of a segment, but inside its file space. We do not include such sections ## address space of a segment, but inside its file space. We do not include such sections
## in a segment when they are at the edges of a segment, because this is a normal case and ## in a segment when they are at the edges of a segment, because this is a normal case and
## it may mean they belong to a different segment. ## it may mean they belong to a different segment.
# RUN: yaml2obj --docnum=8 %s -o %t8 # RUN: yaml2obj --docnum=8 %s -o %t8
# RUN: obj2yaml %t8 | FileCheck %s --check-prefix=BROKEN-VA # RUN: obj2yaml %t8 | FileCheck %s --check-prefix=BROKEN-VA
# BROKEN-VA: ProgramHeaders: # BROKEN-VA: ProgramHeaders:
# BROKEN-VA-NEXT: - Type: PT_LOAD # BROKEN-VA-NEXT: - Type: PT_LOAD
# BROKEN-VA-NEXT: Flags: [ PF_W, PF_R ] # BROKEN-VA-NEXT: Flags: [ PF_W, PF_R ]
# BROKEN-VA-NEXT: Sections: # BROKEN-VA-NEXT: FirstSec: .empty_middle
# BROKEN-VA-NEXT: - Section: .empty_middle # BROKEN-VA-NEXT: LastSec: .empty_middle
# BROKEN-VA-NEXT: VAddr: 0x0000000000001000 # BROKEN-VA-NEXT: VAddr: 0x0000000000001000
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_W, PF_R ] Flags: [ PF_W, PF_R ]
VAddr: 0x1000 VAddr: 0x1000
Sections: FirstSec: .empty_begin
- Section: .empty_begin LastSec: .empty_end
- Section: .empty_middle
- Section: .empty_end
Sections: Sections:
- Name: .empty_begin - Name: .empty_begin
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ] Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0xFEFEFEFE Address: 0xFEFEFEFE
- Type: Fill - Type: Fill
Pattern: "00" Pattern: "00"
Size: 1 Size: 1
Show All 12 Lines

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines - Name: .bar
Size: 0x5 Size: 0x5
Address: 0x100 Address: 0x100
AddressAlign: 2 AddressAlign: 2
- Type: Fill - Type: Fill
Name: fill2 Name: fill2
Pattern: "" Pattern: ""
Size: 0x45 Size: 0x45
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
VAddr: 0x100 VAddr: 0x100
Sections: FirstSec: fill1
- Section: fill1 LastSec: fill2
- Section: .bar
- Section: fill2
- Type: PT_GNU_RELRO - Type: PT_GNU_RELRO
VAddr: 0x105 VAddr: 0x105
Sections: FirstSec: fill2
- Section: fill2 LastSec: fill2
## Check that the "Pattern" field is not mandatory. ## Check that the "Pattern" field is not mandatory.
# RUN: yaml2obj --docnum=4 2>&1 -o %t4 %s # RUN: yaml2obj --docnum=4 2>&1 -o %t4 %s
# RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=NOPATTERN # RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=NOPATTERN
## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40. ## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
# RUN: od -t x1 -v -j 0x40 -N 5 %t4 | FileCheck %s --ignore-case --check-prefix=NOPATTERN-DATA # RUN: od -t x1 -v -j 0x40 -N 5 %t4 | FileCheck %s --ignore-case --check-prefix=NOPATTERN-DATA
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 LinesFileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
Sections: Sections:
- Type: Fill - Type: Fill
Pattern: "00" Pattern: "00"
Size: 0 Size: 0
## Check we report an error when a program header references ## Check we report an error when a program header references
## an unknown section or fill and have at least one Fill defined. ## an unknown section or fill and have at least one Fill defined.
# RUN: not yaml2obj --docnum=10 2>&1 %s | FileCheck %s --check-prefix=UNKNOWN-ERR # RUN: not yaml2obj --docnum=10 2>&1 %s | FileCheck %s --check-prefix=UNKNOWN-ERR
# UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by program header # UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by the 'FirstSec' key of the program header with index 0
# UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by the 'LastSec' key of the program header with index 0
jhendersonUnsubmitted
Done
ReplyInline Actions

We probably need the same test case but for the LastSec key.

jhenderson: We probably need the same test case but for the `LastSec` key.
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
Sections: Sections:
- Type: Fill - Type: Fill
Pattern: "" Pattern: ""
Size: 0 Size: 0
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: fill
- Section: fill LastSec: fill
## Show that we can use the "Offset" key to set an arbitrary offset for a Fill. ## Show that we can use the "Offset" key to set an arbitrary offset for a Fill.
## 0x41 is the minimal possible valid offset for Fill, ## 0x41 is the minimal possible valid offset for Fill,
## because the .foo section of size 0x1 is placed at 0x40. ## because the .foo section of size 0x1 is placed at 0x40.
# RUN: yaml2obj --docnum=11 -DOFFSET=0x41 -o %t11 %s # RUN: yaml2obj --docnum=11 -DOFFSET=0x41 -o %t11 %s
# RUN: llvm-readelf --section-headers %t11 | FileCheck %s --check-prefix=OFFSET-MIN # RUN: llvm-readelf --section-headers %t11 | FileCheck %s --check-prefix=OFFSET-MIN
Show All 37 Lines

llvm/test/tools/yaml2obj/ELF/dynamic-section-i386.yaml

Show All 21 Lines - Name: .dynamic
AddressAlign: 0x0000000000000008 AddressAlign: 0x0000000000000008
EntSize: 0x0000000000000010 EntSize: 0x0000000000000010
Entries: Entries:
- Tag: DT_STRSZ - Tag: DT_STRSZ
Value: 0x0000000000000001 Value: 0x0000000000000001
- Tag: DT_NULL - Tag: DT_NULL
Value: 0x0000000000000000 Value: 0x0000000000000000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0x0000 VAddr: 0x0000
Align: 8 Align: 8
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic
- Type: PT_DYNAMIC - Type: PT_DYNAMIC
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0x0008 VAddr: 0x0008
Sections: FirstSec: .dynamic
- Section: .dynamic LastSec: .dynamic

llvm/test/tools/yaml2obj/ELF/header-sh-fields.yaml

Show All 14 Lines
# DEFAULT: Section header string table index: 2 # DEFAULT: Section header string table index: 2
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_REL Type: ET_REL
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: []
- Type: PT_LOAD - Type: PT_LOAD
Sections: []
## Check we can override all default values using the same values ## Check we can override all default values using the same values
## and that this does not change the output. ## and that this does not change the output.
# RUN: yaml2obj --docnum=2 %s -o %t-default-override # RUN: yaml2obj --docnum=2 %s -o %t-default-override
# RUN: cmp %t-default %t-default-override # RUN: cmp %t-default %t-default-override
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_REL Type: ET_REL
EShEntSize: [[SHENTSIZE=64]] EShEntSize: [[SHENTSIZE=64]]
EShOff: [[SHOFF=200]] EShOff: [[SHOFF=200]]
EShNum: [[SHNUM=3]] EShNum: [[SHNUM=3]]
EShStrNdx: [[SHSTRNDX=2]] EShStrNdx: [[SHSTRNDX=2]]
EPhOff: [[PHOFF=64]] EPhOff: [[PHOFF=64]]
EPhEntSize: [[PHENTSIZE=56]] EPhEntSize: [[PHENTSIZE=56]]
EPhNum: [[PHNUM=2]] EPhNum: [[PHNUM=2]]
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: []
- Type: PT_LOAD - Type: PT_LOAD
Sections: []
## Override different fields to check the output produced. ## Override different fields to check the output produced.
## Override the e_shoff field. ## Override the e_shoff field.
# RUN: yaml2obj --docnum=2 %s -DSHOFF=3 -o %t2 # RUN: yaml2obj --docnum=2 %s -DSHOFF=3 -o %t2
# RUN: llvm-readelf --file-headers %t2 | FileCheck %s --check-prefix=SHOFF # RUN: llvm-readelf --file-headers %t2 | FileCheck %s --check-prefix=SHOFF
# SHOFF: Start of section headers: 3 (bytes into file) # SHOFF: Start of section headers: 3 (bytes into file)
Show All 40 Lines

llvm/test/tools/yaml2obj/ELF/program-header-address.yaml

Show All 22 LinesSections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
Address: 0x1234 Address: 0x1234
ProgramHeaders: ProgramHeaders:
## Show what virtual and physical address we set by default for the case where ## Show what virtual and physical address we set by default for the case where
## a program header has no sections. ## a program header has no sections.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: []
## Show what virtual and physical address we set by default for the case ## Show what virtual and physical address we set by default for the case
## where a program header includes a section with a virtual address that ## where a program header includes a section with a virtual address that
## is explicitly set. ## is explicitly set.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
## Now we have a program header that has a virtual address different to ## Now we have a program header that has a virtual address different to
## the address of the section included. Show that the default physical address ## the address of the section included. Show that the default physical address
## is equal to the program header's virtual address. ## is equal to the program header's virtual address.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xAAAA1000 VAddr: 0xAAAA1000
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
## Show that we are able to set different virtual and physical addresses. ## Show that we are able to set different virtual and physical addresses.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xAAAA1000 VAddr: 0xAAAA1000
PAddr: 0xBBBB2000 PAddr: 0xBBBB2000
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo

llvm/test/tools/yaml2obj/ELF/program-header-align.yaml

Show All 19 Lines - Name: .tdata
Type: SHT_PROGBITS Type: SHT_PROGBITS
AddressAlign: 4 AddressAlign: 4
- Name: .tbss - Name: .tbss
Type: SHT_NOBITS Type: SHT_NOBITS
AddressAlign: 64 AddressAlign: 64
ProgramHeaders: ProgramHeaders:
- Type: PT_TLS - Type: PT_TLS
Align: 16 Align: 16
Sections: FirstSec: .tdata
- Section: .tdata LastSec: .tbss
- Section: .tbss
## If Align is not specified, p_align is inferred from the maximum alignment ## If Align is not specified, p_align is inferred from the maximum alignment
## of contained sections. ## of contained sections.
# RUN: yaml2obj --docnum=2 %s -o %t # RUN: yaml2obj --docnum=2 %s -o %t
# RUN: llvm-readobj -l %t | FileCheck %s # RUN: llvm-readobj -l %t | FileCheck %s
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Sections: Sections:
- Name: .text - Name: .text
Type: SHT_PROGBITS Type: SHT_PROGBITS
AddressAlign: 4 AddressAlign: 4
- Name: .text.hot - Name: .text.hot
Type: SHT_PROGBITS Type: SHT_PROGBITS
AddressAlign: 16 AddressAlign: 16
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .text
- Section: .text LastSec: .text.hot
- Section: .text.hot

llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 LinesSections:
- Name: .data.last - Name: .data.last
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x6 Size: 0x6
ProgramHeaders: ProgramHeaders:
## We have 2 segments, the first is predefined and the second can be customized. ## We have 2 segments, the first is predefined and the second can be customized.
## We want to have more than one segment to show we check all of them when ## We want to have more than one segment to show we check all of them when
## trying to find a non-nobits section after a nobits one. ## trying to find a non-nobits section after a nobits one.
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .data.before
- Section: .data.before LastSec: .nobits.1
- Section: .nobits.1
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: [[SEC1]]
- Section: [[SEC1]] LastSec: [[SEC2]]
- Section: [[SEC2]]
## Case D. We have a segment with SHT_NOBITS sections on its borders and one ## Case D. We have a segment with SHT_NOBITS sections on its borders and one
## non-nobits in the middle. Check we allocate the file space only for ## non-nobits in the middle. Check we allocate the file space only for
## the first nobits section. ## the first nobits section.
# RUN: yaml2obj --docnum=2 %s -o %t4 # RUN: yaml2obj --docnum=2 %s -o %t4
# RUN: llvm-readelf --sections --segments %t4 | FileCheck %s --check-prefix=MIDDLE # RUN: llvm-readelf --sections --segments %t4 | FileCheck %s --check-prefix=MIDDLE
Show All 20 Lines - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x10 Size: 0x10
- Name: .nobits.2 - Name: .nobits.2
Type: SHT_NOBITS Type: SHT_NOBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x100 Size: 0x100
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
Sections: FirstSec: .nobits.1
- Section: .nobits.1 LastSec: .nobits.2
- Section: .data
- Section: .nobits.2

llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 LinesProgramHeaders:
# Program header with no sections. # Program header with no sections.
- Type: 0x6abcdef0 # arbitrary type - Type: 0x6abcdef0 # arbitrary type
Offset: 0x1234 Offset: 0x1234
FileSize: 1111 FileSize: 1111
MemSize: 9999 MemSize: 9999
# Program header with only file size set. # Program header with only file size set.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
FileSize: 6 FileSize: 6
Sections: FirstSec: .rodata
- Section: .rodata LastSec: .rodata
# Program header with only mem size set. # Program header with only mem size set.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
MemSize: 6 MemSize: 6
Sections: FirstSec: .rodata
- Section: .rodata LastSec: .rodata
# Program header with only offset set. # Program header with only offset set.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
Offset: 0x1fff Offset: 0x1fff
Sections: FirstSec: .rodata
- Section: .rodata LastSec: .rodata
# Program header with sections, valid properties. # Program header with sections, valid properties.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
Offset: 0xffe Offset: 0xffe
FileSize: 7 FileSize: 7
MemSize: 9 MemSize: 9
Sections: FirstSec: .text
- Section: .text LastSec: .text
# Program header with invalid properties. # Program header with invalid properties.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
Offset: 0x3000 Offset: 0x3000
FileSize: 3 FileSize: 3
MemSize: 2 MemSize: 2
# Program header with 2 SHT_NOBITS sections. # Program header with 2 SHT_NOBITS sections.
- Type: 0x6abcdef0 - Type: 0x6abcdef0
Offset: 0x2004 Offset: 0x2004
Sections: FirstSec: .data
- Section: .data LastSec: .nobits2
- Section: .nobits1
- Section: .nobits2
## Test the "Offset" property. ## Test the "Offset" property.
## Check that by default the p_offset field of a segment is set to the ## Check that by default the p_offset field of a segment is set to the
## offset of the section with the minimum offset. ## offset of the section with the minimum offset.
# RUN: yaml2obj --docnum=2 %s -o %t2 # RUN: yaml2obj --docnum=2 %s -o %t2
# RUN: llvm-readelf %t2 --sections --program-headers | \ # RUN: llvm-readelf %t2 --sections --program-headers | \
# RUN: FileCheck %s --check-prefixes=DEFAULT-OFFSET # RUN: FileCheck %s --check-prefixes=DEFAULT-OFFSET
Show All 17 Lines - Name: .foo
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
Address: 0x1000 Address: 0x1000
- Name: .bar - Name: .bar
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .foo
- Section: .foo LastSec: .bar
- Section: .bar
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: .bar
- Section: .bar LastSec: .bar
## Check we can set the "Offset" value explicitly to be less than or equal to ## Check we can set the "Offset" value explicitly to be less than or equal to
## the offset of a section in the segment. ## the offset of a section in the segment.
# RUN: yaml2obj --docnum=3 -DOFFSET=0x77 %s -o %t3 # RUN: yaml2obj --docnum=3 -DOFFSET=0x77 %s -o %t3
# RUN: llvm-readelf %t3 --sections --program-headers | \ # RUN: llvm-readelf %t3 --sections --program-headers | \
# RUN: FileCheck %s --check-prefixes=VALID-OFFSET,VALID-OFFSET-LESS # RUN: FileCheck %s --check-prefixes=VALID-OFFSET,VALID-OFFSET-LESS
# RUN: yaml2obj --docnum=3 -DOFFSET=0x78 %s -o %t4 # RUN: yaml2obj --docnum=3 -DOFFSET=0x78 %s -o %t4
# RUN: llvm-readelf %t4 --sections --program-headers | \ # RUN: llvm-readelf %t4 --sections --program-headers | \
Show All 12 LinesFileHeader:
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Sections: Sections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Offset: [[OFFSET]] Offset: [[OFFSET]]
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo
## Check we report an error when the "Offset" value is larger than the offset of a section in the segment. ## Check we report an error when the "Offset" value is larger than the offset of a section in the segment.
# RUN: not yaml2obj --docnum=3 -DOFFSET=0x79 %s -o /dev/null 2>&1 | \ # RUN: not yaml2obj --docnum=3 -DOFFSET=0x79 %s -o /dev/null 2>&1 | \
# RUN: FileCheck %s --check-prefix=INVALID-OFFSET # RUN: FileCheck %s --check-prefix=INVALID-OFFSET
# INVALID-OFFSET: yaml2obj: error: 'Offset' for segment with index 1 must be less than or equal to the minimum file offset of all included sections (0x78) # INVALID-OFFSET: yaml2obj: error: 'Offset' for segment with index 1 must be less than or equal to the minimum file offset of all included sections (0x78)
## Document that the "Offset" value is checked after the section offset is overriden using "ShOffset". ## Document that the "Offset" value is checked after the section offset is overriden using "ShOffset".
Show All 15 LinesSections:
- Name: .foo - Name: .foo
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Size: 0x1 Size: 0x1
## Note: the real .foo offset is much less than 0xFFFFFFFF or ## Note: the real .foo offset is much less than 0xFFFFFFFF or
## 0xFFFFFF00, but no error is reported. ## 0xFFFFFF00, but no error is reported.
ShOffset: 0xFFFFFFFF ShOffset: 0xFFFFFFFF
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Offset: 0xFFFFFF00 Offset: 0xFFFFFF00
Sections: FirstSec: .foo
- Section: .foo LastSec: .foo

llvm/test/tools/yaml2obj/ELF/program-header.yaml

Show All 17 Lines - Name: .init
Content: "00000000" Content: "00000000"
AddressAlign: 0x0000000000000010 AddressAlign: 0x0000000000000010
- Name: .data - Name: .data
Type: SHT_PROGBITS Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ] Flags: [ SHF_ALLOC ]
Content: "00000000" Content: "00000000"
AddressAlign: 0x0000000000001000 AddressAlign: 0x0000000000001000
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_X, PF_R ] Flags: [ PF_X, PF_R ]
VAddr: 0xAAAA1000 VAddr: 0xAAAA1000
PAddr: 0xFFFF1000 PAddr: 0xFFFF1000
Sections: FirstSec: .text
- Section: .text LastSec: .init
- Section: .init
- Type: PT_LOAD - Type: PT_LOAD
Flags: [ PF_R ] Flags: [ PF_R ]
VAddr: 0xAAAA2000 VAddr: 0xAAAA2000
PAddr: 0xFFFF2000 PAddr: 0xFFFF2000
Sections: FirstSec: .data
- Section: .data LastSec: .data
- Type: PT_GNU_EH_FRAME - Type: PT_GNU_EH_FRAME
- Type: PT_GNU_STACK - Type: PT_GNU_STACK
- Type: PT_GNU_RELRO - Type: PT_GNU_RELRO
- Type: PT_GNU_PROPERTY - Type: PT_GNU_PROPERTY
#CHECK: ProgramHeaders [ #CHECK: ProgramHeaders [
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_LOAD #CHECK-NEXT: Type: PT_LOAD
Show All 30 Lines
#CHECK-NEXT: Type: PT_GNU_RELRO (0x6474E552) #CHECK-NEXT: Type: PT_GNU_RELRO (0x6474E552)
#CHECK: } #CHECK: }
#CHECK-NEXT: ProgramHeader { #CHECK-NEXT: ProgramHeader {
#CHECK-NEXT: Type: PT_GNU_PROPERTY (0x6474E553) #CHECK-NEXT: Type: PT_GNU_PROPERTY (0x6474E553)
#CHECK: } #CHECK: }
#CHECK-NEXT:] #CHECK-NEXT:]
## Check we do not allow referencing sections that do not exist. ## Check we do not allow referencing sections that do not exist.
# RUN: not yaml2obj --docnum=2 %s -o %t 2>&1 | FileCheck %s --check-prefix=ERR # RUN: not yaml2obj -DFIRST=".unknown1" -DLAST=".unknown2" --docnum=2 %s 2>&1 | \
# RUN: FileCheck %s --check-prefix=UNKNOWN-ERR
# ERR: error: unknown section or fill referenced: '.foo' by program header # UNKNOWN-ERR: error: unknown section or fill referenced: '.unknown1' by the 'FirstSec' key of the program header with index 0
# ERR: error: unknown section or fill referenced: '.bar' by program header # UNKNOWN-ERR: error: unknown section or fill referenced: '.unknown2' by the 'LastSec' key of the program header with index 0
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_EXEC Type: ET_EXEC
Sections:
- Name: .foo
Type: SHT_PROGBITS
Offset: 0x100
Size: 0x10
- Name: .bar
Type: SHT_PROGBITS
Offset: 0x200
Size: 0x20
- Name: .zed
Type: SHT_PROGBITS
Offset: 0x300
Size: 0x30
- Name: .fill1
Type: Fill
Offset: 0x400
Size: 0x40
- Name: .fill2
Type: Fill
Offset: 0x500
Size: 0x50
ProgramHeaders: ProgramHeaders:
- Type: PT_LOAD - Type: PT_LOAD
Sections: FirstSec: [[FIRST=<none>]]
- Section: .foo LastSec: [[LAST=<none>]]
- Section: .bar
## Check we report an error when the index of the section specified by the "FirstSec" key
jhendersonUnsubmitted
Done
ReplyInline Actions
LastSec: [[LAST=<none>]]
- ## Check we report an error when the index of section spicified by the "FirstSec" key
+ ## Check we report an error when the index of the section specified by the "FirstSec" key
## is greater than the index of section specified by the "LastSec" key.
jhenderson:
## is greater than the index of the section specified by the "LastSec" key.
jhendersonUnsubmitted
Done
ReplyInline Actions
## Check we report an error when the index of section spicified by the "FirstSec" key
- ## is greater than the index of section specified by the "LastSec" key.
+ ## is greater than the index of the section specified by the "LastSec" key.
# RUN: not yaml2obj -DFIRST=".bar" -DLAST=".foo" --docnum=2 %s 2>&1 | \
jhenderson:
# RUN: not yaml2obj -DFIRST=".bar" -DLAST=".foo" --docnum=2 %s 2>&1 | \
# RUN: FileCheck %s --check-prefix=ORDER-ERR
# ORDER-ERR: error: program header with index 0: the section index of .bar is greater than the index of .foo
## Check that we can't use the "LastSec" key without the "FirstSec" key.
# RUN: not yaml2obj -DLAST=".foo" --docnum=2 %s 2>&1 | \
# RUN: FileCheck %s --check-prefix=ONLY-LAST-ERR
# ONLY-LAST-ERR: error: the "LastSec" key can't be used without the "FirstSec" key
## Check that we can't use the "FirstSec" key without the "LastSec" key.
jhendersonUnsubmitted
Done
ReplyInline Actions
# ONLY-LAST-ERR: error: the "LastSec" can't be used without the "FirstSec" key
- ## Check we can specify the "FirstSec" alone to create the segment that includes a single section.
+ ## Check we can specify the "FirstSec" key alone to create the segment that includes a single section.
# RUN: yaml2obj -DFIRST=".foo" --docnum=2 %s -o %t2
jhenderson:
# RUN: not yaml2obj -DFIRST=".foo" --docnum=2 %s 2>&1 | \
# RUN: FileCheck %s --check-prefix=ONLY-FIRST-ERR
# ONLY-FIRST-ERR: error: the "FirstSec" key can't be used without the "LastSec" key
## Check we create an empty segment when neither "FirstSec" nor "LastSec" are specified.
# RUN: yaml2obj --docnum=2 %s -o %t3
# RUN: llvm-readelf --program-headers %t3 | FileCheck %s --check-prefix=EMPTY-SEGMENT
# EMPTY-SEGMENT: Type Offset VirtAddr PhysAddr FileSiz MemSiz
# EMPTY-SEGMENT: LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000
# EMPTY-SEGMENT-EMPTY:
## Check that we include all sections between FirstSec and LastSec in the segment when both keys are used.
# RUN: yaml2obj --docnum=2 -DFIRST=".foo" -DLAST=".zed" %s -o %t4
jhendersonUnsubmitted
Done
ReplyInline Actions
# EMPTY-SEGMENT-EMPTY:
- ## Check that we include all sections in [FirstSec, LastSec] region to the segment when both keys are used.
+ ## Check that we include all sections between FirstSec and LastSec in the segment when both keys are used.
# RUN: yaml2obj --docnum=2 -DFIRST=".foo" -DLAST=".zed" %s -o %t4

Should we have a test case showing that Fills are included as well?

jhenderson: Should we have a test case showing that Fills are included as well?
# RUN: llvm-readelf --program-headers %t4 | FileCheck %s --check-prefix=BOTH
# BOTH: Type Offset VirtAddr PhysAddr FileSiz MemSiz
# BOTH-NEXT: LOAD 0x000100 0x0000000000000000 0x0000000000000000 0x000230 0x000230
## Check that we include fills that are between FirstSec and LastSec in the segment when both keys are used.
# RUN: yaml2obj --docnum=2 -DFIRST=".foo" -DLAST=".fill1" %s -o %t5a
# RUN: llvm-readelf --program-headers %t5a | FileCheck %s --check-prefix=FILL1
# FILL1: Type Offset VirtAddr PhysAddr FileSiz MemSiz
# FILL1: LOAD 0x000100 0x0000000000000000 0x0000000000000000 0x000340 0x000340
# RUN: yaml2obj --docnum=2 -DFIRST=".foo" -DLAST=".fill2" %s -o %t5b
# RUN: llvm-readelf --program-headers %t5b | FileCheck %s --check-prefix=FILL2
# FILL2: Type Offset VirtAddr PhysAddr FileSiz MemSiz
# FILL2: LOAD 0x000100 0x0000000000000000 0x0000000000000000 0x000450 0x000450

llvm/tools/obj2yaml/elf2yaml.cpp

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
// yaml2obj sets the alignment of a segment to 1 by default. // yaml2obj sets the alignment of a segment to 1 by default.
// We do not print the default alignment to reduce noise in the output. // We do not print the default alignment to reduce noise in the output.
if (Phdr.p_align != 1) if (Phdr.p_align != 1)
PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align); PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align);
// Here we match sections with segments. // Here we match sections with segments.
// It is not possible to have a non-Section chunk, because // It is not possible to have a non-Section chunk, because
// obj2yaml does not create Fill chunks. // obj2yaml does not create Fill chunks.
for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) { for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) {
ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get()); ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) {
PH.Sections.push_back({S.Name}); if (!PH.FirstSec)
PH.FirstSec = S.Name;
PH.LastSec = S.Name;
}
} }
jhendersonUnsubmitted
Done
ReplyInline Actions

Does this loop work if section headers are not in section offset order? Or are they guaranteed to be by some sorting earlier on?

jhenderson: Does this loop work if section headers are not in section offset order? Or are they guaranteed…
grimarAuthorUnsubmitted
Done
ReplyInline Actions

I have no short answer, we have a specific behavior for cases where sections are not in the
section offset order currently, let me describe it.

Imagine we have 3 sections:
.foo at offset 0x100, .bar at offset 0x200 and .zed at offset 0x300.
And lets have a section header table where they are in a different order:
.zed (0x300), .foo (0x100) and .bar (0x200).

And lets have a segment [.foo, .zed]. The YAML for this case is shown below:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
Sections:
  - Name:    .foo
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x1
    Offset:  0x100
  - Name:    .bar
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x2
    Offset:  0x200
  - Name:    .zed
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x3
    Offset:  0x300
SectionHeaderTable:
  Sections:
    - Name: .zed
    - Name: .foo
    - Name: .bar
    - Name: .strtab
    - Name: .shstrtab
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_W, PF_R ]
    VAddr:    0x1000
    FirstSec: .foo
    LastSec:  .zed

after applying obj2yaml we have:

--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_EXEC
ProgramHeaders:
  - Type:            PT_LOAD
    Flags:           [ PF_W, PF_R ]
    FirstSec:        .zed
    LastSec:         .bar
    VAddr:           0x0000000000001000
Sections:
  - Name:            .zed
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000003
    Content:         '000000'
  - Name:            .foo
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Content:         '00'
  - Name:            .bar
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000001
    Content:         '0000'
...

What is noticable:

  1. We lost the information about the section header order. I.e. now the order is not .foo .bar. zed, but .zed .foo .bar. Because we dump sections by section header table order only and don't try to preserve section offsets.
  2. FirstSec/LastSec were changed, but they match the YAML produced.
grimar: I have no short answer, we have a specific behavior for cases where sections are not in the…
jhendersonUnsubmitted
Not Done
ReplyInline Actions

My opinion is that we don't need to preserve in the YAML the section header table order, as long as the semantic meaning is identical. Section offset order likely needs maintaining if the sections are inside segments, or any hard-coded addresses will end up breaking, right? It sounds like that might be an issue already though?

jhenderson: My opinion is that we don't need to preserve in the YAML the section header table order, as…
grimarAuthorUnsubmitted
Done
ReplyInline Actions

Yeah, I think so.

I guess we want do dump sections as we do now, but then sort them by file offsets (i.e. sort Chunks) and also emit the Offset field (perhaps not always, but when the aligned [previous offset + size of previous section] value doesn't match the offset of a section dumped).

Though I'd like to experiment with this are probably at first to see if there is something not obvious that I may be missing.

grimar: Yeah, I think so. I guess we want do dump sections as we do now, but then sort them by file…
Ret.push_back(PH); Ret.push_back(PH);
} }
return Ret; return Ret;
} }
template <class ELFT> template <class ELFT>
▲ Show 20 Lines • Show All 1,048 Lines • Show Last 20 Lines