/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Object/ELFObjectFile.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- ELFObjectFile.h - ELF object file implementation ---------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file declares the ELFObjectFile template class. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_OBJECT_ELFOBJECTFILE_H |
14 | | #define LLVM_OBJECT_ELFOBJECTFILE_H |
15 | | |
16 | | #include "llvm/ADT/ArrayRef.h" |
17 | | #include "llvm/ADT/STLExtras.h" |
18 | | #include "llvm/ADT/SmallVector.h" |
19 | | #include "llvm/ADT/StringRef.h" |
20 | | #include "llvm/ADT/Triple.h" |
21 | | #include "llvm/ADT/iterator_range.h" |
22 | | #include "llvm/BinaryFormat/ELF.h" |
23 | | #include "llvm/MC/SubtargetFeature.h" |
24 | | #include "llvm/Object/Binary.h" |
25 | | #include "llvm/Object/ELF.h" |
26 | | #include "llvm/Object/ELFTypes.h" |
27 | | #include "llvm/Object/Error.h" |
28 | | #include "llvm/Object/ObjectFile.h" |
29 | | #include "llvm/Object/SymbolicFile.h" |
30 | | #include "llvm/Support/ARMAttributeParser.h" |
31 | | #include "llvm/Support/ARMBuildAttributes.h" |
32 | | #include "llvm/Support/Casting.h" |
33 | | #include "llvm/Support/Endian.h" |
34 | | #include "llvm/Support/Error.h" |
35 | | #include "llvm/Support/ErrorHandling.h" |
36 | | #include "llvm/Support/MemoryBuffer.h" |
37 | | #include <cassert> |
38 | | #include <cstdint> |
39 | | #include <system_error> |
40 | | |
41 | | namespace llvm { |
42 | | namespace object { |
43 | | |
44 | | constexpr int NumElfSymbolTypes = 8; |
45 | | extern const llvm::EnumEntry<unsigned> ElfSymbolTypes[NumElfSymbolTypes]; |
46 | | |
47 | | class elf_symbol_iterator; |
48 | | |
49 | | class ELFObjectFileBase : public ObjectFile { |
50 | | friend class ELFRelocationRef; |
51 | | friend class ELFSectionRef; |
52 | | friend class ELFSymbolRef; |
53 | | |
54 | | protected: |
55 | | ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source); |
56 | | |
57 | | virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0; |
58 | | virtual uint8_t getSymbolBinding(DataRefImpl Symb) const = 0; |
59 | | virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0; |
60 | | virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0; |
61 | | |
62 | | virtual uint32_t getSectionType(DataRefImpl Sec) const = 0; |
63 | | virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0; |
64 | | virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0; |
65 | | |
66 | | virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0; |
67 | | virtual Error getBuildAttributes(ARMAttributeParser &Attributes) const = 0; |
68 | | |
69 | | public: |
70 | | using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>; |
71 | | |
72 | | virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0; |
73 | | |
74 | | /// Returns platform-specific object flags, if any. |
75 | | virtual unsigned getPlatformFlags() const = 0; |
76 | | |
77 | | elf_symbol_iterator_range symbols() const; |
78 | | |
79 | | static bool classof(const Binary *v) { return v->isELF(); } |
80 | | |
81 | | SubtargetFeatures getFeatures() const override; |
82 | | |
83 | | SubtargetFeatures getMIPSFeatures() const; |
84 | | |
85 | | SubtargetFeatures getARMFeatures() const; |
86 | | |
87 | | SubtargetFeatures getRISCVFeatures() const; |
88 | | |
89 | | void setARMSubArch(Triple &TheTriple) const override; |
90 | | |
91 | | virtual uint16_t getEType() const = 0; |
92 | | |
93 | | virtual uint16_t getEMachine() const = 0; |
94 | | |
95 | | std::vector<std::pair<DataRefImpl, uint64_t>> getPltAddresses() const; |
96 | | }; |
97 | | |
98 | | class ELFSectionRef : public SectionRef { |
99 | | public: |
100 | | ELFSectionRef(const SectionRef &B) : SectionRef(B) { |
101 | | assert(isa<ELFObjectFileBase>(SectionRef::getObject())); |
102 | | } |
103 | | |
104 | | const ELFObjectFileBase *getObject() const { |
105 | | return cast<ELFObjectFileBase>(SectionRef::getObject()); |
106 | | } |
107 | | |
108 | | uint32_t getType() const { |
109 | | return getObject()->getSectionType(getRawDataRefImpl()); |
110 | | } |
111 | | |
112 | | uint64_t getFlags() const { |
113 | | return getObject()->getSectionFlags(getRawDataRefImpl()); |
114 | | } |
115 | | |
116 | 0 | uint64_t getOffset() const { |
117 | 0 | return getObject()->getSectionOffset(getRawDataRefImpl()); |
118 | 0 | } |
119 | | }; |
120 | | |
121 | | class elf_section_iterator : public section_iterator { |
122 | | public: |
123 | | elf_section_iterator(const section_iterator &B) : section_iterator(B) { |
124 | | assert(isa<ELFObjectFileBase>(B->getObject())); |
125 | | } |
126 | | |
127 | | const ELFSectionRef *operator->() const { |
128 | | return static_cast<const ELFSectionRef *>(section_iterator::operator->()); |
129 | | } |
130 | | |
131 | 0 | const ELFSectionRef &operator*() const { |
132 | 0 | return static_cast<const ELFSectionRef &>(section_iterator::operator*()); |
133 | 0 | } |
134 | | }; |
135 | | |
136 | | class ELFSymbolRef : public SymbolRef { |
137 | | public: |
138 | | ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) { |
139 | | assert(isa<ELFObjectFileBase>(SymbolRef::getObject())); |
140 | | } |
141 | | |
142 | | const ELFObjectFileBase *getObject() const { |
143 | | return cast<ELFObjectFileBase>(BasicSymbolRef::getObject()); |
144 | | } |
145 | | |
146 | | uint64_t getSize() const { |
147 | | return getObject()->getSymbolSize(getRawDataRefImpl()); |
148 | | } |
149 | | |
150 | | uint8_t getBinding() const { |
151 | | return getObject()->getSymbolBinding(getRawDataRefImpl()); |
152 | | } |
153 | | |
154 | | uint8_t getOther() const { |
155 | | return getObject()->getSymbolOther(getRawDataRefImpl()); |
156 | | } |
157 | | |
158 | | uint8_t getELFType() const { |
159 | | return getObject()->getSymbolELFType(getRawDataRefImpl()); |
160 | | } |
161 | | |
162 | | StringRef getELFTypeName() const { |
163 | | uint8_t Type = getELFType(); |
164 | | for (auto &EE : ElfSymbolTypes) { |
165 | | if (EE.Value == Type) { |
166 | | return EE.AltName; |
167 | | } |
168 | | } |
169 | | return ""; |
170 | | } |
171 | | }; |
172 | | |
173 | | class elf_symbol_iterator : public symbol_iterator { |
174 | | public: |
175 | | elf_symbol_iterator(const basic_symbol_iterator &B) |
176 | | : symbol_iterator(SymbolRef(B->getRawDataRefImpl(), |
177 | 3.57k | cast<ELFObjectFileBase>(B->getObject()))) {} |
178 | | |
179 | | const ELFSymbolRef *operator->() const { |
180 | | return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->()); |
181 | | } |
182 | | |
183 | | const ELFSymbolRef &operator*() const { |
184 | | return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*()); |
185 | | } |
186 | | }; |
187 | | |
188 | | class ELFRelocationRef : public RelocationRef { |
189 | | public: |
190 | 7.91k | ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) { |
191 | 7.91k | assert(isa<ELFObjectFileBase>(RelocationRef::getObject())); |
192 | 7.91k | } |
193 | | |
194 | 7.91k | const ELFObjectFileBase *getObject() const { |
195 | 7.91k | return cast<ELFObjectFileBase>(RelocationRef::getObject()); |
196 | 7.91k | } |
197 | | |
198 | 7.91k | Expected<int64_t> getAddend() const { |
199 | 7.91k | return getObject()->getRelocationAddend(getRawDataRefImpl()); |
200 | 7.91k | } |
201 | | }; |
202 | | |
203 | | class elf_relocation_iterator : public relocation_iterator { |
204 | | public: |
205 | | elf_relocation_iterator(const relocation_iterator &B) |
206 | | : relocation_iterator(RelocationRef( |
207 | 0 | B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {} |
208 | | |
209 | 0 | const ELFRelocationRef *operator->() const { |
210 | 0 | return static_cast<const ELFRelocationRef *>( |
211 | 0 | relocation_iterator::operator->()); |
212 | 0 | } |
213 | | |
214 | 0 | const ELFRelocationRef &operator*() const { |
215 | 0 | return static_cast<const ELFRelocationRef &>( |
216 | 0 | relocation_iterator::operator*()); |
217 | 0 | } |
218 | | }; |
219 | | |
220 | | inline ELFObjectFileBase::elf_symbol_iterator_range |
221 | | ELFObjectFileBase::symbols() const { |
222 | | return elf_symbol_iterator_range(symbol_begin(), symbol_end()); |
223 | | } |
224 | | |
225 | | template <class ELFT> class ELFObjectFile : public ELFObjectFileBase { |
226 | | uint16_t getEMachine() const override; |
227 | | uint16_t getEType() const override; |
228 | | uint64_t getSymbolSize(DataRefImpl Sym) const override; |
229 | | |
230 | | public: |
231 | | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) |
232 | | |
233 | | using uintX_t = typename ELFT::uint; |
234 | | |
235 | | using Elf_Sym = typename ELFT::Sym; |
236 | | using Elf_Shdr = typename ELFT::Shdr; |
237 | | using Elf_Ehdr = typename ELFT::Ehdr; |
238 | | using Elf_Rel = typename ELFT::Rel; |
239 | | using Elf_Rela = typename ELFT::Rela; |
240 | | using Elf_Dyn = typename ELFT::Dyn; |
241 | | |
242 | | private: |
243 | | ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF, |
244 | | const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec, |
245 | | ArrayRef<Elf_Word> ShndxTable); |
246 | | |
247 | | protected: |
248 | | ELFFile<ELFT> EF; |
249 | | |
250 | | const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section. |
251 | | const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section. |
252 | | ArrayRef<Elf_Word> ShndxTable; |
253 | | |
254 | | void moveSymbolNext(DataRefImpl &Symb) const override; |
255 | | Expected<StringRef> getSymbolName(DataRefImpl Symb) const override; |
256 | | Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override; |
257 | | uint64_t getSymbolValueImpl(DataRefImpl Symb) const override; |
258 | | uint32_t getSymbolAlignment(DataRefImpl Symb) const override; |
259 | | uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override; |
260 | | uint32_t getSymbolFlags(DataRefImpl Symb) const override; |
261 | | uint8_t getSymbolBinding(DataRefImpl Symb) const override; |
262 | | uint8_t getSymbolOther(DataRefImpl Symb) const override; |
263 | | uint8_t getSymbolELFType(DataRefImpl Symb) const override; |
264 | | Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override; |
265 | | Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb, |
266 | | const Elf_Shdr *SymTab) const; |
267 | | Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override; |
268 | | |
269 | | void moveSectionNext(DataRefImpl &Sec) const override; |
270 | | Expected<StringRef> getSectionName(DataRefImpl Sec) const override; |
271 | | uint64_t getSectionAddress(DataRefImpl Sec) const override; |
272 | | uint64_t getSectionIndex(DataRefImpl Sec) const override; |
273 | | uint64_t getSectionSize(DataRefImpl Sec) const override; |
274 | | Expected<ArrayRef<uint8_t>> |
275 | | getSectionContents(DataRefImpl Sec) const override; |
276 | | uint64_t getSectionAlignment(DataRefImpl Sec) const override; |
277 | | bool isSectionCompressed(DataRefImpl Sec) const override; |
278 | | bool isSectionText(DataRefImpl Sec) const override; |
279 | | bool isSectionData(DataRefImpl Sec) const override; |
280 | | bool isSectionBSS(DataRefImpl Sec) const override; |
281 | | bool isSectionVirtual(DataRefImpl Sec) const override; |
282 | | bool isBerkeleyText(DataRefImpl Sec) const override; |
283 | | bool isBerkeleyData(DataRefImpl Sec) const override; |
284 | | relocation_iterator section_rel_begin(DataRefImpl Sec) const override; |
285 | | relocation_iterator section_rel_end(DataRefImpl Sec) const override; |
286 | | std::vector<SectionRef> dynamic_relocation_sections() const override; |
287 | | section_iterator getRelocatedSection(DataRefImpl Sec) const override; |
288 | | |
289 | | void moveRelocationNext(DataRefImpl &Rel) const override; |
290 | | uint64_t getRelocationOffset(DataRefImpl Rel) const override; |
291 | | symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override; |
292 | | uint64_t getRelocationType(DataRefImpl Rel) const override; |
293 | | void getRelocationTypeName(DataRefImpl Rel, |
294 | | SmallVectorImpl<char> &Result) const override; |
295 | | |
296 | | uint32_t getSectionType(DataRefImpl Sec) const override; |
297 | | uint64_t getSectionFlags(DataRefImpl Sec) const override; |
298 | | uint64_t getSectionOffset(DataRefImpl Sec) const override; |
299 | | StringRef getRelocationTypeName(uint32_t Type) const; |
300 | | |
301 | | /// Get the relocation section that contains \a Rel. |
302 | 45.6k | const Elf_Shdr *getRelSection(DataRefImpl Rel) const { |
303 | 45.6k | auto RelSecOrErr = EF.getSection(Rel.d.a); |
304 | 45.6k | if (!RelSecOrErr) |
305 | 0 | report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); |
306 | 45.6k | return *RelSecOrErr; |
307 | 45.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelSection(llvm::object::DataRefImpl) const Line | Count | Source | 302 | 5.11k | const Elf_Shdr *getRelSection(DataRefImpl Rel) const { | 303 | 5.11k | auto RelSecOrErr = EF.getSection(Rel.d.a); | 304 | 5.11k | if (!RelSecOrErr) | 305 | 0 | report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); | 306 | 5.11k | return *RelSecOrErr; | 307 | 5.11k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelSection(llvm::object::DataRefImpl) const Line | Count | Source | 302 | 1.79k | const Elf_Shdr *getRelSection(DataRefImpl Rel) const { | 303 | 1.79k | auto RelSecOrErr = EF.getSection(Rel.d.a); | 304 | 1.79k | if (!RelSecOrErr) | 305 | 0 | report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); | 306 | 1.79k | return *RelSecOrErr; | 307 | 1.79k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelSection(llvm::object::DataRefImpl) const Line | Count | Source | 302 | 37.1k | const Elf_Shdr *getRelSection(DataRefImpl Rel) const { | 303 | 37.1k | auto RelSecOrErr = EF.getSection(Rel.d.a); | 304 | 37.1k | if (!RelSecOrErr) | 305 | 0 | report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); | 306 | 37.1k | return *RelSecOrErr; | 307 | 37.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelSection(llvm::object::DataRefImpl) const Line | Count | Source | 302 | 1.54k | const Elf_Shdr *getRelSection(DataRefImpl Rel) const { | 303 | 1.54k | auto RelSecOrErr = EF.getSection(Rel.d.a); | 304 | 1.54k | if (!RelSecOrErr) | 305 | 0 | report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); | 306 | 1.54k | return *RelSecOrErr; | 307 | 1.54k | } |
|
308 | | |
309 | 14.3k | DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { |
310 | 14.3k | DataRefImpl DRI; |
311 | 14.3k | if (!SymTable) { |
312 | 554 | DRI.d.a = 0; |
313 | 554 | DRI.d.b = 0; |
314 | 554 | return DRI; |
315 | 554 | } |
316 | 13.7k | assert(SymTable->sh_type == ELF::SHT_SYMTAB || |
317 | 13.7k | SymTable->sh_type == ELF::SHT_DYNSYM); |
318 | 13.7k | |
319 | 13.7k | auto SectionsOrErr = EF.sections(); |
320 | 13.7k | if (!SectionsOrErr) { |
321 | 0 | DRI.d.a = 0; |
322 | 0 | DRI.d.b = 0; |
323 | 0 | return DRI; |
324 | 0 | } |
325 | 13.7k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); |
326 | 13.7k | unsigned SymTableIndex = |
327 | 13.7k | (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); |
328 | 13.7k | |
329 | 13.7k | DRI.d.a = SymTableIndex; |
330 | 13.7k | DRI.d.b = SymbolNum; |
331 | 13.7k | return DRI; |
332 | 13.7k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*, unsigned int) const Line | Count | Source | 309 | 2.24k | DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { | 310 | 2.24k | DataRefImpl DRI; | 311 | 2.24k | if (!SymTable) { | 312 | 318 | DRI.d.a = 0; | 313 | 318 | DRI.d.b = 0; | 314 | 318 | return DRI; | 315 | 318 | } | 316 | 1.92k | assert(SymTable->sh_type == ELF::SHT_SYMTAB || | 317 | 1.92k | SymTable->sh_type == ELF::SHT_DYNSYM); | 318 | 1.92k | | 319 | 1.92k | auto SectionsOrErr = EF.sections(); | 320 | 1.92k | if (!SectionsOrErr) { | 321 | 0 | DRI.d.a = 0; | 322 | 0 | DRI.d.b = 0; | 323 | 0 | return DRI; | 324 | 0 | } | 325 | 1.92k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 326 | 1.92k | unsigned SymTableIndex = | 327 | 1.92k | (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); | 328 | 1.92k | | 329 | 1.92k | DRI.d.a = SymTableIndex; | 330 | 1.92k | DRI.d.b = SymbolNum; | 331 | 1.92k | return DRI; | 332 | 1.92k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*, unsigned int) const Line | Count | Source | 309 | 590 | DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { | 310 | 590 | DataRefImpl DRI; | 311 | 590 | if (!SymTable) { | 312 | 14 | DRI.d.a = 0; | 313 | 14 | DRI.d.b = 0; | 314 | 14 | return DRI; | 315 | 14 | } | 316 | 576 | assert(SymTable->sh_type == ELF::SHT_SYMTAB || | 317 | 576 | SymTable->sh_type == ELF::SHT_DYNSYM); | 318 | 576 | | 319 | 576 | auto SectionsOrErr = EF.sections(); | 320 | 576 | if (!SectionsOrErr) { | 321 | 0 | DRI.d.a = 0; | 322 | 0 | DRI.d.b = 0; | 323 | 0 | return DRI; | 324 | 0 | } | 325 | 576 | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 326 | 576 | unsigned SymTableIndex = | 327 | 576 | (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); | 328 | 576 | | 329 | 576 | DRI.d.a = SymTableIndex; | 330 | 576 | DRI.d.b = SymbolNum; | 331 | 576 | return DRI; | 332 | 576 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*, unsigned int) const Line | Count | Source | 309 | 11.0k | DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { | 310 | 11.0k | DataRefImpl DRI; | 311 | 11.0k | if (!SymTable) { | 312 | 220 | DRI.d.a = 0; | 313 | 220 | DRI.d.b = 0; | 314 | 220 | return DRI; | 315 | 220 | } | 316 | 10.8k | assert(SymTable->sh_type == ELF::SHT_SYMTAB || | 317 | 10.8k | SymTable->sh_type == ELF::SHT_DYNSYM); | 318 | 10.8k | | 319 | 10.8k | auto SectionsOrErr = EF.sections(); | 320 | 10.8k | if (!SectionsOrErr) { | 321 | 0 | DRI.d.a = 0; | 322 | 0 | DRI.d.b = 0; | 323 | 0 | return DRI; | 324 | 0 | } | 325 | 10.8k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 326 | 10.8k | unsigned SymTableIndex = | 327 | 10.8k | (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); | 328 | 10.8k | | 329 | 10.8k | DRI.d.a = SymTableIndex; | 330 | 10.8k | DRI.d.b = SymbolNum; | 331 | 10.8k | return DRI; | 332 | 10.8k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*, unsigned int) const Line | Count | Source | 309 | 445 | DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { | 310 | 445 | DataRefImpl DRI; | 311 | 445 | if (!SymTable) { | 312 | 2 | DRI.d.a = 0; | 313 | 2 | DRI.d.b = 0; | 314 | 2 | return DRI; | 315 | 2 | } | 316 | 443 | assert(SymTable->sh_type == ELF::SHT_SYMTAB || | 317 | 443 | SymTable->sh_type == ELF::SHT_DYNSYM); | 318 | 443 | | 319 | 443 | auto SectionsOrErr = EF.sections(); | 320 | 443 | if (!SectionsOrErr) { | 321 | 0 | DRI.d.a = 0; | 322 | 0 | DRI.d.b = 0; | 323 | 0 | return DRI; | 324 | 0 | } | 325 | 443 | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 326 | 443 | unsigned SymTableIndex = | 327 | 443 | (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); | 328 | 443 | | 329 | 443 | DRI.d.a = SymTableIndex; | 330 | 443 | DRI.d.b = SymbolNum; | 331 | 443 | return DRI; | 332 | 443 | } |
|
333 | | |
334 | | const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const { |
335 | | return reinterpret_cast<const Elf_Shdr *>(Sec.p); |
336 | | } |
337 | | |
338 | 231k | DataRefImpl toDRI(const Elf_Shdr *Sec) const { |
339 | 231k | DataRefImpl DRI; |
340 | 231k | DRI.p = reinterpret_cast<uintptr_t>(Sec); |
341 | 231k | return DRI; |
342 | 231k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*) const Line | Count | Source | 338 | 32.5k | DataRefImpl toDRI(const Elf_Shdr *Sec) const { | 339 | 32.5k | DataRefImpl DRI; | 340 | 32.5k | DRI.p = reinterpret_cast<uintptr_t>(Sec); | 341 | 32.5k | return DRI; | 342 | 32.5k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*) const Line | Count | Source | 338 | 9.79k | DataRefImpl toDRI(const Elf_Shdr *Sec) const { | 339 | 9.79k | DataRefImpl DRI; | 340 | 9.79k | DRI.p = reinterpret_cast<uintptr_t>(Sec); | 341 | 9.79k | return DRI; | 342 | 9.79k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*) const Line | Count | Source | 338 | 181k | DataRefImpl toDRI(const Elf_Shdr *Sec) const { | 339 | 181k | DataRefImpl DRI; | 340 | 181k | DRI.p = reinterpret_cast<uintptr_t>(Sec); | 341 | 181k | return DRI; | 342 | 181k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::toDRI(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*) const Line | Count | Source | 338 | 7.15k | DataRefImpl toDRI(const Elf_Shdr *Sec) const { | 339 | 7.15k | DataRefImpl DRI; | 340 | 7.15k | DRI.p = reinterpret_cast<uintptr_t>(Sec); | 341 | 7.15k | return DRI; | 342 | 7.15k | } |
|
343 | | |
344 | | DataRefImpl toDRI(const Elf_Dyn *Dyn) const { |
345 | | DataRefImpl DRI; |
346 | | DRI.p = reinterpret_cast<uintptr_t>(Dyn); |
347 | | return DRI; |
348 | | } |
349 | | |
350 | 45.6k | bool isExportedToOtherDSO(const Elf_Sym *ESym) const { |
351 | 45.6k | unsigned char Binding = ESym->getBinding(); |
352 | 45.6k | unsigned char Visibility = ESym->getVisibility(); |
353 | 45.6k | |
354 | 45.6k | // A symbol is exported if its binding is either GLOBAL or WEAK, and its |
355 | 45.6k | // visibility is either DEFAULT or PROTECTED. All other symbols are not |
356 | 45.6k | // exported. |
357 | 45.6k | return ( |
358 | 45.6k | (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK26.8k || |
359 | 45.6k | Binding == ELF::STB_GNU_UNIQUE22.8k ) && |
360 | 45.6k | (22.8k Visibility == ELF::STV_DEFAULT22.8k || Visibility == ELF::STV_PROTECTED8.78k )); |
361 | 45.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isExportedToOtherDSO(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*) const Line | Count | Source | 350 | 9.14k | bool isExportedToOtherDSO(const Elf_Sym *ESym) const { | 351 | 9.14k | unsigned char Binding = ESym->getBinding(); | 352 | 9.14k | unsigned char Visibility = ESym->getVisibility(); | 353 | 9.14k | | 354 | 9.14k | // A symbol is exported if its binding is either GLOBAL or WEAK, and its | 355 | 9.14k | // visibility is either DEFAULT or PROTECTED. All other symbols are not | 356 | 9.14k | // exported. | 357 | 9.14k | return ( | 358 | 9.14k | (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK5.63k || | 359 | 9.14k | Binding == ELF::STB_GNU_UNIQUE5.61k ) && | 360 | 9.14k | (3.53k Visibility == ELF::STV_DEFAULT3.53k || Visibility == ELF::STV_PROTECTED10 )); | 361 | 9.14k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isExportedToOtherDSO(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*) const Line | Count | Source | 350 | 1.19k | bool isExportedToOtherDSO(const Elf_Sym *ESym) const { | 351 | 1.19k | unsigned char Binding = ESym->getBinding(); | 352 | 1.19k | unsigned char Visibility = ESym->getVisibility(); | 353 | 1.19k | | 354 | 1.19k | // A symbol is exported if its binding is either GLOBAL or WEAK, and its | 355 | 1.19k | // visibility is either DEFAULT or PROTECTED. All other symbols are not | 356 | 1.19k | // exported. | 357 | 1.19k | return ( | 358 | 1.19k | (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK755 || | 359 | 1.19k | Binding == ELF::STB_GNU_UNIQUE747 ) && | 360 | 1.19k | (444 Visibility == ELF::STV_DEFAULT444 || Visibility == ELF::STV_PROTECTED0 )); | 361 | 1.19k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isExportedToOtherDSO(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*) const Line | Count | Source | 350 | 34.4k | bool isExportedToOtherDSO(const Elf_Sym *ESym) const { | 351 | 34.4k | unsigned char Binding = ESym->getBinding(); | 352 | 34.4k | unsigned char Visibility = ESym->getVisibility(); | 353 | 34.4k | | 354 | 34.4k | // A symbol is exported if its binding is either GLOBAL or WEAK, and its | 355 | 34.4k | // visibility is either DEFAULT or PROTECTED. All other symbols are not | 356 | 34.4k | // exported. | 357 | 34.4k | return ( | 358 | 34.4k | (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK19.9k || | 359 | 34.4k | Binding == ELF::STB_GNU_UNIQUE15.9k ) && | 360 | 34.4k | (18.5k Visibility == ELF::STV_DEFAULT18.5k || Visibility == ELF::STV_PROTECTED8.76k )); | 361 | 34.4k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isExportedToOtherDSO(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*) const Line | Count | Source | 350 | 839 | bool isExportedToOtherDSO(const Elf_Sym *ESym) const { | 351 | 839 | unsigned char Binding = ESym->getBinding(); | 352 | 839 | unsigned char Visibility = ESym->getVisibility(); | 353 | 839 | | 354 | 839 | // A symbol is exported if its binding is either GLOBAL or WEAK, and its | 355 | 839 | // visibility is either DEFAULT or PROTECTED. All other symbols are not | 356 | 839 | // exported. | 357 | 839 | return ( | 358 | 839 | (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK522 || | 359 | 839 | Binding == ELF::STB_GNU_UNIQUE513 ) && | 360 | 839 | (326 Visibility == ELF::STV_DEFAULT326 || Visibility == ELF::STV_PROTECTED10 )); | 361 | 839 | } |
|
362 | | |
363 | 270 | Error getBuildAttributes(ARMAttributeParser &Attributes) const override { |
364 | 270 | auto SectionsOrErr = EF.sections(); |
365 | 270 | if (!SectionsOrErr) |
366 | 0 | return SectionsOrErr.takeError(); |
367 | 270 | |
368 | 1.75k | for (const Elf_Shdr &Sec : *SectionsOrErr)270 { |
369 | 1.75k | if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) { |
370 | 167 | auto ErrorOrContents = EF.getSectionContents(&Sec); |
371 | 167 | if (!ErrorOrContents) |
372 | 0 | return ErrorOrContents.takeError(); |
373 | 167 | |
374 | 167 | auto Contents = ErrorOrContents.get(); |
375 | 167 | if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1) |
376 | 0 | return Error::success(); |
377 | 167 | |
378 | 167 | Attributes.Parse(Contents, ELFT::TargetEndianness == support::little); |
379 | 167 | break; |
380 | 167 | } |
381 | 1.75k | } |
382 | 270 | return Error::success(); |
383 | 270 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getBuildAttributes(llvm::ARMAttributeParser&) const Line | Count | Source | 363 | 270 | Error getBuildAttributes(ARMAttributeParser &Attributes) const override { | 364 | 270 | auto SectionsOrErr = EF.sections(); | 365 | 270 | if (!SectionsOrErr) | 366 | 0 | return SectionsOrErr.takeError(); | 367 | 270 | | 368 | 1.75k | for (const Elf_Shdr &Sec : *SectionsOrErr)270 { | 369 | 1.75k | if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) { | 370 | 167 | auto ErrorOrContents = EF.getSectionContents(&Sec); | 371 | 167 | if (!ErrorOrContents) | 372 | 0 | return ErrorOrContents.takeError(); | 373 | 167 | | 374 | 167 | auto Contents = ErrorOrContents.get(); | 375 | 167 | if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1) | 376 | 0 | return Error::success(); | 377 | 167 | | 378 | 167 | Attributes.Parse(Contents, ELFT::TargetEndianness == support::little); | 379 | 167 | break; | 380 | 167 | } | 381 | 1.75k | } | 382 | 270 | return Error::success(); | 383 | 270 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getBuildAttributes(llvm::ARMAttributeParser&) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getBuildAttributes(llvm::ARMAttributeParser&) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getBuildAttributes(llvm::ARMAttributeParser&) const |
384 | | |
385 | | // This flag is used for classof, to distinguish ELFObjectFile from |
386 | | // its subclass. If more subclasses will be created, this flag will |
387 | | // have to become an enum. |
388 | | bool isDyldELFObject; |
389 | | |
390 | | public: |
391 | | ELFObjectFile(ELFObjectFile<ELFT> &&Other); |
392 | | static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object); |
393 | | |
394 | | const Elf_Rel *getRel(DataRefImpl Rel) const; |
395 | | const Elf_Rela *getRela(DataRefImpl Rela) const; |
396 | | |
397 | 207k | const Elf_Sym *getSymbol(DataRefImpl Sym) const { |
398 | 207k | auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); |
399 | 207k | if (!Ret) |
400 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); |
401 | 207k | return *Ret; |
402 | 207k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 397 | 57.4k | const Elf_Sym *getSymbol(DataRefImpl Sym) const { | 398 | 57.4k | auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); | 399 | 57.4k | if (!Ret) | 400 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 401 | 57.4k | return *Ret; | 402 | 57.4k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 397 | 5.56k | const Elf_Sym *getSymbol(DataRefImpl Sym) const { | 398 | 5.56k | auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); | 399 | 5.56k | if (!Ret) | 400 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 401 | 5.56k | return *Ret; | 402 | 5.56k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 397 | 141k | const Elf_Sym *getSymbol(DataRefImpl Sym) const { | 398 | 141k | auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); | 399 | 141k | if (!Ret) | 400 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 401 | 141k | return *Ret; | 402 | 141k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 397 | 3.51k | const Elf_Sym *getSymbol(DataRefImpl Sym) const { | 398 | 3.51k | auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); | 399 | 3.51k | if (!Ret) | 400 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 401 | 3.51k | return *Ret; | 402 | 3.51k | } |
|
403 | | |
404 | 664k | const Elf_Shdr *getSection(DataRefImpl Sec) const { |
405 | 664k | return reinterpret_cast<const Elf_Shdr *>(Sec.p); |
406 | 664k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSection(llvm::object::DataRefImpl) const Line | Count | Source | 404 | 83.1k | const Elf_Shdr *getSection(DataRefImpl Sec) const { | 405 | 83.1k | return reinterpret_cast<const Elf_Shdr *>(Sec.p); | 406 | 83.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSection(llvm::object::DataRefImpl) const Line | Count | Source | 404 | 18.1k | const Elf_Shdr *getSection(DataRefImpl Sec) const { | 405 | 18.1k | return reinterpret_cast<const Elf_Shdr *>(Sec.p); | 406 | 18.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSection(llvm::object::DataRefImpl) const Line | Count | Source | 404 | 550k | const Elf_Shdr *getSection(DataRefImpl Sec) const { | 405 | 550k | return reinterpret_cast<const Elf_Shdr *>(Sec.p); | 406 | 550k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSection(llvm::object::DataRefImpl) const Line | Count | Source | 404 | 13.1k | const Elf_Shdr *getSection(DataRefImpl Sec) const { | 405 | 13.1k | return reinterpret_cast<const Elf_Shdr *>(Sec.p); | 406 | 13.1k | } |
|
407 | | |
408 | | basic_symbol_iterator symbol_begin() const override; |
409 | | basic_symbol_iterator symbol_end() const override; |
410 | | |
411 | | elf_symbol_iterator dynamic_symbol_begin() const; |
412 | | elf_symbol_iterator dynamic_symbol_end() const; |
413 | | |
414 | | section_iterator section_begin() const override; |
415 | | section_iterator section_end() const override; |
416 | | |
417 | | Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override; |
418 | | |
419 | | uint8_t getBytesInAddress() const override; |
420 | | StringRef getFileFormatName() const override; |
421 | | Triple::ArchType getArch() const override; |
422 | | Expected<uint64_t> getStartAddress() const override; |
423 | | |
424 | 323 | unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getPlatformFlags() const Line | Count | Source | 424 | 124 | unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getPlatformFlags() const Line | Count | Source | 424 | 82 | unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getPlatformFlags() const Line | Count | Source | 424 | 95 | unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getPlatformFlags() const Line | Count | Source | 424 | 22 | unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } |
|
425 | | |
426 | | const ELFFile<ELFT> *getELFFile() const { return &EF; } |
427 | | |
428 | | bool isDyldType() const { return isDyldELFObject; } |
429 | | static bool classof(const Binary *v) { |
430 | | return v->getType() == getELFType(ELFT::TargetEndianness == support::little, |
431 | | ELFT::Is64Bits); |
432 | | } |
433 | | |
434 | | elf_symbol_iterator_range getDynamicSymbolIterators() const override; |
435 | | |
436 | | bool isRelocatableObject() const override; |
437 | | }; |
438 | | |
439 | | using ELF32LEObjectFile = ELFObjectFile<ELF32LE>; |
440 | | using ELF64LEObjectFile = ELFObjectFile<ELF64LE>; |
441 | | using ELF32BEObjectFile = ELFObjectFile<ELF32BE>; |
442 | | using ELF64BEObjectFile = ELFObjectFile<ELF64BE>; |
443 | | |
444 | | template <class ELFT> |
445 | 33.5k | void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { |
446 | 33.5k | ++Sym.d.b; |
447 | 33.5k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::moveSymbolNext(llvm::object::DataRefImpl&) const Line | Count | Source | 445 | 8.21k | void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { | 446 | 8.21k | ++Sym.d.b; | 447 | 8.21k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::moveSymbolNext(llvm::object::DataRefImpl&) const Line | Count | Source | 445 | 738 | void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { | 446 | 738 | ++Sym.d.b; | 447 | 738 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::moveSymbolNext(llvm::object::DataRefImpl&) const Line | Count | Source | 445 | 24.1k | void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { | 446 | 24.1k | ++Sym.d.b; | 447 | 24.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::moveSymbolNext(llvm::object::DataRefImpl&) const Line | Count | Source | 445 | 469 | void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { | 446 | 469 | ++Sym.d.b; | 447 | 469 | } |
|
448 | | |
449 | | template <class ELFT> |
450 | 35.8k | Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { |
451 | 35.8k | const Elf_Sym *ESym = getSymbol(Sym); |
452 | 35.8k | auto SymTabOrErr = EF.getSection(Sym.d.a); |
453 | 35.8k | if (!SymTabOrErr) |
454 | 0 | return SymTabOrErr.takeError(); |
455 | 35.8k | const Elf_Shdr *SymTableSec = *SymTabOrErr; |
456 | 35.8k | auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); |
457 | 35.8k | if (!StrTabOrErr) |
458 | 0 | return StrTabOrErr.takeError(); |
459 | 35.8k | const Elf_Shdr *StringTableSec = *StrTabOrErr; |
460 | 35.8k | auto SymStrTabOrErr = EF.getStringTable(StringTableSec); |
461 | 35.8k | if (!SymStrTabOrErr) |
462 | 1 | return SymStrTabOrErr.takeError(); |
463 | 35.8k | Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); |
464 | 35.8k | |
465 | 35.8k | // If the symbol name is empty use the section name. |
466 | 35.8k | if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION1.08k ) { |
467 | 960 | StringRef SecName; |
468 | 960 | Expected<section_iterator> Sec = getSymbolSection(Sym); |
469 | 960 | if (Sec && !(*Sec)->getName(SecName)) |
470 | 960 | return SecName; |
471 | 34.9k | } |
472 | 34.9k | return Name; |
473 | 34.9k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolName(llvm::object::DataRefImpl) const Line | Count | Source | 450 | 14.6k | Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { | 451 | 14.6k | const Elf_Sym *ESym = getSymbol(Sym); | 452 | 14.6k | auto SymTabOrErr = EF.getSection(Sym.d.a); | 453 | 14.6k | if (!SymTabOrErr) | 454 | 0 | return SymTabOrErr.takeError(); | 455 | 14.6k | const Elf_Shdr *SymTableSec = *SymTabOrErr; | 456 | 14.6k | auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); | 457 | 14.6k | if (!StrTabOrErr) | 458 | 0 | return StrTabOrErr.takeError(); | 459 | 14.6k | const Elf_Shdr *StringTableSec = *StrTabOrErr; | 460 | 14.6k | auto SymStrTabOrErr = EF.getStringTable(StringTableSec); | 461 | 14.6k | if (!SymStrTabOrErr) | 462 | 0 | return SymStrTabOrErr.takeError(); | 463 | 14.6k | Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); | 464 | 14.6k | | 465 | 14.6k | // If the symbol name is empty use the section name. | 466 | 14.6k | if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION382 ) { | 467 | 323 | StringRef SecName; | 468 | 323 | Expected<section_iterator> Sec = getSymbolSection(Sym); | 469 | 323 | if (Sec && !(*Sec)->getName(SecName)) | 470 | 323 | return SecName; | 471 | 14.3k | } | 472 | 14.3k | return Name; | 473 | 14.3k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolName(llvm::object::DataRefImpl) const Line | Count | Source | 450 | 798 | Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { | 451 | 798 | const Elf_Sym *ESym = getSymbol(Sym); | 452 | 798 | auto SymTabOrErr = EF.getSection(Sym.d.a); | 453 | 798 | if (!SymTabOrErr) | 454 | 0 | return SymTabOrErr.takeError(); | 455 | 798 | const Elf_Shdr *SymTableSec = *SymTabOrErr; | 456 | 798 | auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); | 457 | 798 | if (!StrTabOrErr) | 458 | 0 | return StrTabOrErr.takeError(); | 459 | 798 | const Elf_Shdr *StringTableSec = *StrTabOrErr; | 460 | 798 | auto SymStrTabOrErr = EF.getStringTable(StringTableSec); | 461 | 798 | if (!SymStrTabOrErr) | 462 | 0 | return SymStrTabOrErr.takeError(); | 463 | 798 | Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); | 464 | 798 | | 465 | 798 | // If the symbol name is empty use the section name. | 466 | 798 | if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION49 ) { | 467 | 36 | StringRef SecName; | 468 | 36 | Expected<section_iterator> Sec = getSymbolSection(Sym); | 469 | 36 | if (Sec && !(*Sec)->getName(SecName)) | 470 | 36 | return SecName; | 471 | 762 | } | 472 | 762 | return Name; | 473 | 762 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolName(llvm::object::DataRefImpl) const Line | Count | Source | 450 | 19.9k | Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { | 451 | 19.9k | const Elf_Sym *ESym = getSymbol(Sym); | 452 | 19.9k | auto SymTabOrErr = EF.getSection(Sym.d.a); | 453 | 19.9k | if (!SymTabOrErr) | 454 | 0 | return SymTabOrErr.takeError(); | 455 | 19.9k | const Elf_Shdr *SymTableSec = *SymTabOrErr; | 456 | 19.9k | auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); | 457 | 19.9k | if (!StrTabOrErr) | 458 | 0 | return StrTabOrErr.takeError(); | 459 | 19.9k | const Elf_Shdr *StringTableSec = *StrTabOrErr; | 460 | 19.9k | auto SymStrTabOrErr = EF.getStringTable(StringTableSec); | 461 | 19.9k | if (!SymStrTabOrErr) | 462 | 1 | return SymStrTabOrErr.takeError(); | 463 | 19.9k | Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); | 464 | 19.9k | | 465 | 19.9k | // If the symbol name is empty use the section name. | 466 | 19.9k | if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION622 ) { | 467 | 579 | StringRef SecName; | 468 | 579 | Expected<section_iterator> Sec = getSymbolSection(Sym); | 469 | 579 | if (Sec && !(*Sec)->getName(SecName)) | 470 | 579 | return SecName; | 471 | 19.3k | } | 472 | 19.3k | return Name; | 473 | 19.3k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolName(llvm::object::DataRefImpl) const Line | Count | Source | 450 | 484 | Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { | 451 | 484 | const Elf_Sym *ESym = getSymbol(Sym); | 452 | 484 | auto SymTabOrErr = EF.getSection(Sym.d.a); | 453 | 484 | if (!SymTabOrErr) | 454 | 0 | return SymTabOrErr.takeError(); | 455 | 484 | const Elf_Shdr *SymTableSec = *SymTabOrErr; | 456 | 484 | auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); | 457 | 484 | if (!StrTabOrErr) | 458 | 0 | return StrTabOrErr.takeError(); | 459 | 484 | const Elf_Shdr *StringTableSec = *StrTabOrErr; | 460 | 484 | auto SymStrTabOrErr = EF.getStringTable(StringTableSec); | 461 | 484 | if (!SymStrTabOrErr) | 462 | 0 | return SymStrTabOrErr.takeError(); | 463 | 484 | Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); | 464 | 484 | | 465 | 484 | // If the symbol name is empty use the section name. | 466 | 484 | if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION29 ) { | 467 | 22 | StringRef SecName; | 468 | 22 | Expected<section_iterator> Sec = getSymbolSection(Sym); | 469 | 22 | if (Sec && !(*Sec)->getName(SecName)) | 470 | 22 | return SecName; | 471 | 462 | } | 472 | 462 | return Name; | 473 | 462 | } |
|
474 | | |
475 | | template <class ELFT> |
476 | 6.05k | uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { |
477 | 6.05k | return getSection(Sec)->sh_flags; |
478 | 6.05k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionFlags(llvm::object::DataRefImpl) const Line | Count | Source | 476 | 939 | uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { | 477 | 939 | return getSection(Sec)->sh_flags; | 478 | 939 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionFlags(llvm::object::DataRefImpl) const Line | Count | Source | 476 | 344 | uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { | 477 | 344 | return getSection(Sec)->sh_flags; | 478 | 344 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionFlags(llvm::object::DataRefImpl) const Line | Count | Source | 476 | 4.46k | uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { | 477 | 4.46k | return getSection(Sec)->sh_flags; | 478 | 4.46k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionFlags(llvm::object::DataRefImpl) const Line | Count | Source | 476 | 312 | uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { | 477 | 312 | return getSection(Sec)->sh_flags; | 478 | 312 | } |
|
479 | | |
480 | | template <class ELFT> |
481 | 1.24k | uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { |
482 | 1.24k | return getSection(Sec)->sh_type; |
483 | 1.24k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionType(llvm::object::DataRefImpl) const Line | Count | Source | 481 | 146 | uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { | 482 | 146 | return getSection(Sec)->sh_type; | 483 | 146 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionType(llvm::object::DataRefImpl) const Line | Count | Source | 481 | 89 | uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { | 482 | 89 | return getSection(Sec)->sh_type; | 483 | 89 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionType(llvm::object::DataRefImpl) const Line | Count | Source | 481 | 905 | uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { | 482 | 905 | return getSection(Sec)->sh_type; | 483 | 905 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionType(llvm::object::DataRefImpl) const Line | Count | Source | 481 | 104 | uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { | 482 | 104 | return getSection(Sec)->sh_type; | 483 | 104 | } |
|
484 | | |
485 | | template <class ELFT> |
486 | 0 | uint64_t ELFObjectFile<ELFT>::getSectionOffset(DataRefImpl Sec) const { |
487 | 0 | return getSection(Sec)->sh_offset; |
488 | 0 | } Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionOffset(llvm::object::DataRefImpl) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionOffset(llvm::object::DataRefImpl) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionOffset(llvm::object::DataRefImpl) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionOffset(llvm::object::DataRefImpl) const |
489 | | |
490 | | template <class ELFT> |
491 | 29.7k | uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { |
492 | 29.7k | const Elf_Sym *ESym = getSymbol(Symb); |
493 | 29.7k | uint64_t Ret = ESym->st_value; |
494 | 29.7k | if (ESym->st_shndx == ELF::SHN_ABS) |
495 | 662 | return Ret; |
496 | 29.0k | |
497 | 29.0k | const Elf_Ehdr *Header = EF.getHeader(); |
498 | 29.0k | // Clear the ARM/Thumb or microMIPS indicator flag. |
499 | 29.0k | if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS22.8k ) && |
500 | 29.0k | ESym->getType() == ELF::STT_FUNC7.17k ) |
501 | 3.09k | Ret &= ~1; |
502 | 29.0k | |
503 | 29.0k | return Ret; |
504 | 29.0k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolValueImpl(llvm::object::DataRefImpl) const Line | Count | Source | 491 | 7.97k | uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { | 492 | 7.97k | const Elf_Sym *ESym = getSymbol(Symb); | 493 | 7.97k | uint64_t Ret = ESym->st_value; | 494 | 7.97k | if (ESym->st_shndx == ELF::SHN_ABS) | 495 | 164 | return Ret; | 496 | 7.80k | | 497 | 7.80k | const Elf_Ehdr *Header = EF.getHeader(); | 498 | 7.80k | // Clear the ARM/Thumb or microMIPS indicator flag. | 499 | 7.80k | if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS1.59k ) && | 500 | 7.80k | ESym->getType() == ELF::STT_FUNC6.37k ) | 501 | 2.88k | Ret &= ~1; | 502 | 7.80k | | 503 | 7.80k | return Ret; | 504 | 7.80k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolValueImpl(llvm::object::DataRefImpl) const Line | Count | Source | 491 | 723 | uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { | 492 | 723 | const Elf_Sym *ESym = getSymbol(Symb); | 493 | 723 | uint64_t Ret = ESym->st_value; | 494 | 723 | if (ESym->st_shndx == ELF::SHN_ABS) | 495 | 32 | return Ret; | 496 | 691 | | 497 | 691 | const Elf_Ehdr *Header = EF.getHeader(); | 498 | 691 | // Clear the ARM/Thumb or microMIPS indicator flag. | 499 | 691 | if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS673 ) && | 500 | 691 | ESym->getType() == ELF::STT_FUNC597 ) | 501 | 166 | Ret &= ~1; | 502 | 691 | | 503 | 691 | return Ret; | 504 | 691 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolValueImpl(llvm::object::DataRefImpl) const Line | Count | Source | 491 | 20.6k | uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { | 492 | 20.6k | const Elf_Sym *ESym = getSymbol(Symb); | 493 | 20.6k | uint64_t Ret = ESym->st_value; | 494 | 20.6k | if (ESym->st_shndx == ELF::SHN_ABS) | 495 | 450 | return Ret; | 496 | 20.1k | | 497 | 20.1k | const Elf_Ehdr *Header = EF.getHeader(); | 498 | 20.1k | // Clear the ARM/Thumb or microMIPS indicator flag. | 499 | 20.1k | if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS20.1k ) && | 500 | 20.1k | ESym->getType() == ELF::STT_FUNC69 ) | 501 | 30 | Ret &= ~1; | 502 | 20.1k | | 503 | 20.1k | return Ret; | 504 | 20.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolValueImpl(llvm::object::DataRefImpl) const Line | Count | Source | 491 | 432 | uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { | 492 | 432 | const Elf_Sym *ESym = getSymbol(Symb); | 493 | 432 | uint64_t Ret = ESym->st_value; | 494 | 432 | if (ESym->st_shndx == ELF::SHN_ABS) | 495 | 16 | return Ret; | 496 | 416 | | 497 | 416 | const Elf_Ehdr *Header = EF.getHeader(); | 498 | 416 | // Clear the ARM/Thumb or microMIPS indicator flag. | 499 | 416 | if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) && | 500 | 416 | ESym->getType() == ELF::STT_FUNC136 ) | 501 | 11 | Ret &= ~1; | 502 | 416 | | 503 | 416 | return Ret; | 504 | 416 | } |
|
505 | | |
506 | | template <class ELFT> |
507 | | Expected<uint64_t> |
508 | 30.6k | ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { |
509 | 30.6k | uint64_t Result = getSymbolValue(Symb); |
510 | 30.6k | const Elf_Sym *ESym = getSymbol(Symb); |
511 | 30.6k | switch (ESym->st_shndx) { |
512 | 30.6k | case ELF::SHN_COMMON: |
513 | 1.57k | case ELF::SHN_UNDEF: |
514 | 1.57k | case ELF::SHN_ABS: |
515 | 1.57k | return Result; |
516 | 29.0k | } |
517 | 29.0k | |
518 | 29.0k | const Elf_Ehdr *Header = EF.getHeader(); |
519 | 29.0k | auto SymTabOrErr = EF.getSection(Symb.d.a); |
520 | 29.0k | if (!SymTabOrErr) |
521 | 0 | return SymTabOrErr.takeError(); |
522 | 29.0k | const Elf_Shdr *SymTab = *SymTabOrErr; |
523 | 29.0k | |
524 | 29.0k | if (Header->e_type == ELF::ET_REL) { |
525 | 7.17k | auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); |
526 | 7.17k | if (!SectionOrErr) |
527 | 0 | return SectionOrErr.takeError(); |
528 | 7.17k | const Elf_Shdr *Section = *SectionOrErr; |
529 | 7.17k | if (Section) |
530 | 7.16k | Result += Section->sh_addr; |
531 | 7.17k | } |
532 | 29.0k | |
533 | 29.0k | return Result; |
534 | 29.0k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolAddress(llvm::object::DataRefImpl) const Line | Count | Source | 508 | 8.24k | ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { | 509 | 8.24k | uint64_t Result = getSymbolValue(Symb); | 510 | 8.24k | const Elf_Sym *ESym = getSymbol(Symb); | 511 | 8.24k | switch (ESym->st_shndx) { | 512 | 8.24k | case ELF::SHN_COMMON: | 513 | 441 | case ELF::SHN_UNDEF: | 514 | 441 | case ELF::SHN_ABS: | 515 | 441 | return Result; | 516 | 7.80k | } | 517 | 7.80k | | 518 | 7.80k | const Elf_Ehdr *Header = EF.getHeader(); | 519 | 7.80k | auto SymTabOrErr = EF.getSection(Symb.d.a); | 520 | 7.80k | if (!SymTabOrErr) | 521 | 0 | return SymTabOrErr.takeError(); | 522 | 7.80k | const Elf_Shdr *SymTab = *SymTabOrErr; | 523 | 7.80k | | 524 | 7.80k | if (Header->e_type == ELF::ET_REL) { | 525 | 1.95k | auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 526 | 1.95k | if (!SectionOrErr) | 527 | 0 | return SectionOrErr.takeError(); | 528 | 1.95k | const Elf_Shdr *Section = *SectionOrErr; | 529 | 1.95k | if (Section) | 530 | 1.95k | Result += Section->sh_addr; | 531 | 1.95k | } | 532 | 7.80k | | 533 | 7.80k | return Result; | 534 | 7.80k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolAddress(llvm::object::DataRefImpl) const Line | Count | Source | 508 | 784 | ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { | 509 | 784 | uint64_t Result = getSymbolValue(Symb); | 510 | 784 | const Elf_Sym *ESym = getSymbol(Symb); | 511 | 784 | switch (ESym->st_shndx) { | 512 | 784 | case ELF::SHN_COMMON: | 513 | 93 | case ELF::SHN_UNDEF: | 514 | 93 | case ELF::SHN_ABS: | 515 | 93 | return Result; | 516 | 691 | } | 517 | 691 | | 518 | 691 | const Elf_Ehdr *Header = EF.getHeader(); | 519 | 691 | auto SymTabOrErr = EF.getSection(Symb.d.a); | 520 | 691 | if (!SymTabOrErr) | 521 | 0 | return SymTabOrErr.takeError(); | 522 | 691 | const Elf_Shdr *SymTab = *SymTabOrErr; | 523 | 691 | | 524 | 691 | if (Header->e_type == ELF::ET_REL) { | 525 | 256 | auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 526 | 256 | if (!SectionOrErr) | 527 | 0 | return SectionOrErr.takeError(); | 528 | 256 | const Elf_Shdr *Section = *SectionOrErr; | 529 | 256 | if (Section) | 530 | 256 | Result += Section->sh_addr; | 531 | 256 | } | 532 | 691 | | 533 | 691 | return Result; | 534 | 691 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolAddress(llvm::object::DataRefImpl) const Line | Count | Source | 508 | 21.1k | ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { | 509 | 21.1k | uint64_t Result = getSymbolValue(Symb); | 510 | 21.1k | const Elf_Sym *ESym = getSymbol(Symb); | 511 | 21.1k | switch (ESym->st_shndx) { | 512 | 21.1k | case ELF::SHN_COMMON: | 513 | 993 | case ELF::SHN_UNDEF: | 514 | 993 | case ELF::SHN_ABS: | 515 | 993 | return Result; | 516 | 20.1k | } | 517 | 20.1k | | 518 | 20.1k | const Elf_Ehdr *Header = EF.getHeader(); | 519 | 20.1k | auto SymTabOrErr = EF.getSection(Symb.d.a); | 520 | 20.1k | if (!SymTabOrErr) | 521 | 0 | return SymTabOrErr.takeError(); | 522 | 20.1k | const Elf_Shdr *SymTab = *SymTabOrErr; | 523 | 20.1k | | 524 | 20.1k | if (Header->e_type == ELF::ET_REL) { | 525 | 4.79k | auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 526 | 4.79k | if (!SectionOrErr) | 527 | 0 | return SectionOrErr.takeError(); | 528 | 4.79k | const Elf_Shdr *Section = *SectionOrErr; | 529 | 4.79k | if (Section) | 530 | 4.78k | Result += Section->sh_addr; | 531 | 4.79k | } | 532 | 20.1k | | 533 | 20.1k | return Result; | 534 | 20.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolAddress(llvm::object::DataRefImpl) const Line | Count | Source | 508 | 462 | ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { | 509 | 462 | uint64_t Result = getSymbolValue(Symb); | 510 | 462 | const Elf_Sym *ESym = getSymbol(Symb); | 511 | 462 | switch (ESym->st_shndx) { | 512 | 462 | case ELF::SHN_COMMON: | 513 | 46 | case ELF::SHN_UNDEF: | 514 | 46 | case ELF::SHN_ABS: | 515 | 46 | return Result; | 516 | 416 | } | 517 | 416 | | 518 | 416 | const Elf_Ehdr *Header = EF.getHeader(); | 519 | 416 | auto SymTabOrErr = EF.getSection(Symb.d.a); | 520 | 416 | if (!SymTabOrErr) | 521 | 0 | return SymTabOrErr.takeError(); | 522 | 416 | const Elf_Shdr *SymTab = *SymTabOrErr; | 523 | 416 | | 524 | 416 | if (Header->e_type == ELF::ET_REL) { | 525 | 170 | auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 526 | 170 | if (!SectionOrErr) | 527 | 0 | return SectionOrErr.takeError(); | 528 | 170 | const Elf_Shdr *Section = *SectionOrErr; | 529 | 170 | if (Section) | 530 | 170 | Result += Section->sh_addr; | 531 | 170 | } | 532 | 416 | | 533 | 416 | return Result; | 534 | 416 | } |
|
535 | | |
536 | | template <class ELFT> |
537 | 99 | uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { |
538 | 99 | const Elf_Sym *Sym = getSymbol(Symb); |
539 | 99 | if (Sym->st_shndx == ELF::SHN_COMMON) |
540 | 99 | return Sym->st_value; |
541 | 0 | return 0; |
542 | 0 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 537 | 6 | uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { | 538 | 6 | const Elf_Sym *Sym = getSymbol(Symb); | 539 | 6 | if (Sym->st_shndx == ELF::SHN_COMMON) | 540 | 6 | return Sym->st_value; | 541 | 0 | return 0; | 542 | 0 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 537 | 4 | uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { | 538 | 4 | const Elf_Sym *Sym = getSymbol(Symb); | 539 | 4 | if (Sym->st_shndx == ELF::SHN_COMMON) | 540 | 4 | return Sym->st_value; | 541 | 0 | return 0; | 542 | 0 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 537 | 87 | uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { | 538 | 87 | const Elf_Sym *Sym = getSymbol(Symb); | 539 | 87 | if (Sym->st_shndx == ELF::SHN_COMMON) | 540 | 87 | return Sym->st_value; | 541 | 0 | return 0; | 542 | 0 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 537 | 2 | uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { | 538 | 2 | const Elf_Sym *Sym = getSymbol(Symb); | 539 | 2 | if (Sym->st_shndx == ELF::SHN_COMMON) | 540 | 2 | return Sym->st_value; | 541 | 0 | return 0; | 542 | 0 | } |
|
543 | | |
544 | | template <class ELFT> |
545 | 20.4k | uint16_t ELFObjectFile<ELFT>::getEMachine() const { |
546 | 20.4k | return EF.getHeader()->e_machine; |
547 | 20.4k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getEMachine() const Line | Count | Source | 545 | 5.60k | uint16_t ELFObjectFile<ELFT>::getEMachine() const { | 546 | 5.60k | return EF.getHeader()->e_machine; | 547 | 5.60k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getEMachine() const Line | Count | Source | 545 | 1.13k | uint16_t ELFObjectFile<ELFT>::getEMachine() const { | 546 | 1.13k | return EF.getHeader()->e_machine; | 547 | 1.13k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getEMachine() const Line | Count | Source | 545 | 13.0k | uint16_t ELFObjectFile<ELFT>::getEMachine() const { | 546 | 13.0k | return EF.getHeader()->e_machine; | 547 | 13.0k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getEMachine() const Line | Count | Source | 545 | 645 | uint16_t ELFObjectFile<ELFT>::getEMachine() const { | 546 | 645 | return EF.getHeader()->e_machine; | 547 | 645 | } |
|
548 | | |
549 | 1 | template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const { |
550 | 1 | return EF.getHeader()->e_type; |
551 | 1 | } Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getEType() const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getEType() const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getEType() const Line | Count | Source | 549 | 1 | template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const { | 550 | 1 | return EF.getHeader()->e_type; | 551 | 1 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getEType() const |
552 | | |
553 | | template <class ELFT> |
554 | 11.3k | uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { |
555 | 11.3k | return getSymbol(Sym)->st_size; |
556 | 11.3k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolSize(llvm::object::DataRefImpl) const Line | Count | Source | 554 | 303 | uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { | 555 | 303 | return getSymbol(Sym)->st_size; | 556 | 303 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolSize(llvm::object::DataRefImpl) const Line | Count | Source | 554 | 146 | uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { | 555 | 146 | return getSymbol(Sym)->st_size; | 556 | 146 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolSize(llvm::object::DataRefImpl) const Line | Count | Source | 554 | 10.8k | uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { | 555 | 10.8k | return getSymbol(Sym)->st_size; | 556 | 10.8k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolSize(llvm::object::DataRefImpl) const Line | Count | Source | 554 | 75 | uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { | 555 | 75 | return getSymbol(Sym)->st_size; | 556 | 75 | } |
|
557 | | |
558 | | template <class ELFT> |
559 | 145 | uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { |
560 | 145 | return getSymbol(Symb)->st_size; |
561 | 145 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getCommonSymbolSizeImpl(llvm::object::DataRefImpl) const Line | Count | Source | 559 | 13 | uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { | 560 | 13 | return getSymbol(Symb)->st_size; | 561 | 13 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getCommonSymbolSizeImpl(llvm::object::DataRefImpl) const Line | Count | Source | 559 | 5 | uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { | 560 | 5 | return getSymbol(Symb)->st_size; | 561 | 5 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getCommonSymbolSizeImpl(llvm::object::DataRefImpl) const Line | Count | Source | 559 | 124 | uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { | 560 | 124 | return getSymbol(Symb)->st_size; | 561 | 124 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getCommonSymbolSizeImpl(llvm::object::DataRefImpl) const Line | Count | Source | 559 | 3 | uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { | 560 | 3 | return getSymbol(Symb)->st_size; | 561 | 3 | } |
|
562 | | |
563 | | template <class ELFT> |
564 | 1.20k | uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { |
565 | 1.20k | return getSymbol(Symb)->getBinding(); |
566 | 1.20k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolBinding(llvm::object::DataRefImpl) const Line | Count | Source | 564 | 90 | uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { | 565 | 90 | return getSymbol(Symb)->getBinding(); | 566 | 90 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolBinding(llvm::object::DataRefImpl) const Line | Count | Source | 564 | 5 | uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { | 565 | 5 | return getSymbol(Symb)->getBinding(); | 566 | 5 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolBinding(llvm::object::DataRefImpl) const Line | Count | Source | 564 | 1.08k | uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { | 565 | 1.08k | return getSymbol(Symb)->getBinding(); | 566 | 1.08k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolBinding(llvm::object::DataRefImpl) const Line | Count | Source | 564 | 25 | uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { | 565 | 25 | return getSymbol(Symb)->getBinding(); | 566 | 25 | } |
|
567 | | |
568 | | template <class ELFT> |
569 | 765 | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { |
570 | 765 | return getSymbol(Symb)->st_other; |
571 | 765 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolOther(llvm::object::DataRefImpl) const Line | Count | Source | 569 | 125 | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { | 570 | 125 | return getSymbol(Symb)->st_other; | 571 | 125 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolOther(llvm::object::DataRefImpl) const Line | Count | Source | 569 | 139 | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { | 570 | 139 | return getSymbol(Symb)->st_other; | 571 | 139 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolOther(llvm::object::DataRefImpl) const Line | Count | Source | 569 | 455 | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { | 570 | 455 | return getSymbol(Symb)->st_other; | 571 | 455 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolOther(llvm::object::DataRefImpl) const Line | Count | Source | 569 | 46 | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { | 570 | 46 | return getSymbol(Symb)->st_other; | 571 | 46 | } |
|
572 | | |
573 | | template <class ELFT> |
574 | 991 | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { |
575 | 991 | return getSymbol(Symb)->getType(); |
576 | 991 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolELFType(llvm::object::DataRefImpl) const Line | Count | Source | 574 | 85 | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { | 575 | 85 | return getSymbol(Symb)->getType(); | 576 | 85 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolELFType(llvm::object::DataRefImpl) const Line | Count | Source | 574 | 7 | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { | 575 | 7 | return getSymbol(Symb)->getType(); | 576 | 7 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolELFType(llvm::object::DataRefImpl) const Line | Count | Source | 574 | 883 | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { | 575 | 883 | return getSymbol(Symb)->getType(); | 576 | 883 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolELFType(llvm::object::DataRefImpl) const Line | Count | Source | 574 | 16 | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { | 575 | 16 | return getSymbol(Symb)->getType(); | 576 | 16 | } |
|
577 | | |
578 | | template <class ELFT> |
579 | | Expected<SymbolRef::Type> |
580 | 10.3k | ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { |
581 | 10.3k | const Elf_Sym *ESym = getSymbol(Symb); |
582 | 10.3k | |
583 | 10.3k | switch (ESym->getType()) { |
584 | 10.3k | case ELF::STT_NOTYPE: |
585 | 1.30k | return SymbolRef::ST_Unknown; |
586 | 10.3k | case ELF::STT_SECTION: |
587 | 2.97k | return SymbolRef::ST_Debug; |
588 | 10.3k | case ELF::STT_FILE: |
589 | 103 | return SymbolRef::ST_File; |
590 | 10.3k | case ELF::STT_FUNC: |
591 | 2.92k | return SymbolRef::ST_Function; |
592 | 10.3k | case ELF::STT_OBJECT: |
593 | 3.05k | case ELF::STT_COMMON: |
594 | 3.05k | case ELF::STT_TLS: |
595 | 3.05k | return SymbolRef::ST_Data; |
596 | 3.05k | default: |
597 | 0 | return SymbolRef::ST_Other; |
598 | 10.3k | } |
599 | 10.3k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolType(llvm::object::DataRefImpl) const Line | Count | Source | 580 | 326 | ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { | 581 | 326 | const Elf_Sym *ESym = getSymbol(Symb); | 582 | 326 | | 583 | 326 | switch (ESym->getType()) { | 584 | 326 | case ELF::STT_NOTYPE: | 585 | 174 | return SymbolRef::ST_Unknown; | 586 | 326 | case ELF::STT_SECTION: | 587 | 66 | return SymbolRef::ST_Debug; | 588 | 326 | case ELF::STT_FILE: | 589 | 16 | return SymbolRef::ST_File; | 590 | 326 | case ELF::STT_FUNC: | 591 | 40 | return SymbolRef::ST_Function; | 592 | 326 | case ELF::STT_OBJECT: | 593 | 30 | case ELF::STT_COMMON: | 594 | 30 | case ELF::STT_TLS: | 595 | 30 | return SymbolRef::ST_Data; | 596 | 30 | default: | 597 | 0 | return SymbolRef::ST_Other; | 598 | 326 | } | 599 | 326 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolType(llvm::object::DataRefImpl) const Line | Count | Source | 580 | 268 | ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { | 581 | 268 | const Elf_Sym *ESym = getSymbol(Symb); | 582 | 268 | | 583 | 268 | switch (ESym->getType()) { | 584 | 268 | case ELF::STT_NOTYPE: | 585 | 167 | return SymbolRef::ST_Unknown; | 586 | 268 | case ELF::STT_SECTION: | 587 | 17 | return SymbolRef::ST_Debug; | 588 | 268 | case ELF::STT_FILE: | 589 | 10 | return SymbolRef::ST_File; | 590 | 268 | case ELF::STT_FUNC: | 591 | 36 | return SymbolRef::ST_Function; | 592 | 268 | case ELF::STT_OBJECT: | 593 | 38 | case ELF::STT_COMMON: | 594 | 38 | case ELF::STT_TLS: | 595 | 38 | return SymbolRef::ST_Data; | 596 | 38 | default: | 597 | 0 | return SymbolRef::ST_Other; | 598 | 268 | } | 599 | 268 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolType(llvm::object::DataRefImpl) const Line | Count | Source | 580 | 9.56k | ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { | 581 | 9.56k | const Elf_Sym *ESym = getSymbol(Symb); | 582 | 9.56k | | 583 | 9.56k | switch (ESym->getType()) { | 584 | 9.56k | case ELF::STT_NOTYPE: | 585 | 857 | return SymbolRef::ST_Unknown; | 586 | 9.56k | case ELF::STT_SECTION: | 587 | 2.86k | return SymbolRef::ST_Debug; | 588 | 9.56k | case ELF::STT_FILE: | 589 | 65 | return SymbolRef::ST_File; | 590 | 9.56k | case ELF::STT_FUNC: | 591 | 2.81k | return SymbolRef::ST_Function; | 592 | 9.56k | case ELF::STT_OBJECT: | 593 | 2.96k | case ELF::STT_COMMON: | 594 | 2.96k | case ELF::STT_TLS: | 595 | 2.96k | return SymbolRef::ST_Data; | 596 | 2.96k | default: | 597 | 0 | return SymbolRef::ST_Other; | 598 | 9.56k | } | 599 | 9.56k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolType(llvm::object::DataRefImpl) const Line | Count | Source | 580 | 204 | ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { | 581 | 204 | const Elf_Sym *ESym = getSymbol(Symb); | 582 | 204 | | 583 | 204 | switch (ESym->getType()) { | 584 | 204 | case ELF::STT_NOTYPE: | 585 | 111 | return SymbolRef::ST_Unknown; | 586 | 204 | case ELF::STT_SECTION: | 587 | 28 | return SymbolRef::ST_Debug; | 588 | 204 | case ELF::STT_FILE: | 589 | 12 | return SymbolRef::ST_File; | 590 | 204 | case ELF::STT_FUNC: | 591 | 34 | return SymbolRef::ST_Function; | 592 | 204 | case ELF::STT_OBJECT: | 593 | 19 | case ELF::STT_COMMON: | 594 | 19 | case ELF::STT_TLS: | 595 | 19 | return SymbolRef::ST_Data; | 596 | 19 | default: | 597 | 0 | return SymbolRef::ST_Other; | 598 | 204 | } | 599 | 204 | } |
|
600 | | |
601 | | template <class ELFT> |
602 | 45.6k | uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { |
603 | 45.6k | const Elf_Sym *ESym = getSymbol(Sym); |
604 | 45.6k | |
605 | 45.6k | uint32_t Result = SymbolRef::SF_None; |
606 | 45.6k | |
607 | 45.6k | if (ESym->getBinding() != ELF::STB_LOCAL) |
608 | 22.8k | Result |= SymbolRef::SF_Global; |
609 | 45.6k | |
610 | 45.6k | if (ESym->getBinding() == ELF::STB_WEAK) |
611 | 4.07k | Result |= SymbolRef::SF_Weak; |
612 | 45.6k | |
613 | 45.6k | if (ESym->st_shndx == ELF::SHN_ABS) |
614 | 1.43k | Result |= SymbolRef::SF_Absolute; |
615 | 45.6k | |
616 | 45.6k | if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION44.6k ) |
617 | 5.18k | Result |= SymbolRef::SF_FormatSpecific; |
618 | 45.6k | |
619 | 45.6k | auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); |
620 | 45.6k | if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) |
621 | 0 | Result |= SymbolRef::SF_FormatSpecific; |
622 | 45.6k | auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); |
623 | 45.6k | if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) |
624 | 7 | Result |= SymbolRef::SF_FormatSpecific; |
625 | 45.6k | |
626 | 45.6k | if (EF.getHeader()->e_machine == ELF::EM_ARM) { |
627 | 6.63k | if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { |
628 | 6.63k | StringRef Name = *NameOrErr; |
629 | 6.63k | if (Name.startswith("$d") || Name.startswith("$t")6.42k || |
630 | 6.63k | Name.startswith("$a")4.35k ) |
631 | 3.01k | Result |= SymbolRef::SF_FormatSpecific; |
632 | 6.63k | } else { |
633 | 0 | // TODO: Actually report errors helpfully. |
634 | 0 | consumeError(NameOrErr.takeError()); |
635 | 0 | } |
636 | 6.63k | if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 12.91k ) |
637 | 2.21k | Result |= SymbolRef::SF_Thumb; |
638 | 6.63k | } |
639 | 45.6k | |
640 | 45.6k | if (ESym->st_shndx == ELF::SHN_UNDEF) |
641 | 1.65k | Result |= SymbolRef::SF_Undefined; |
642 | 45.6k | |
643 | 45.6k | if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON45.6k ) |
644 | 468 | Result |= SymbolRef::SF_Common; |
645 | 45.6k | |
646 | 45.6k | if (isExportedToOtherDSO(ESym)) |
647 | 14.1k | Result |= SymbolRef::SF_Exported; |
648 | 45.6k | |
649 | 45.6k | if (ESym->getVisibility() == ELF::STV_HIDDEN) |
650 | 10.7k | Result |= SymbolRef::SF_Hidden; |
651 | 45.6k | |
652 | 45.6k | return Result; |
653 | 45.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolFlags(llvm::object::DataRefImpl) const Line | Count | Source | 602 | 9.14k | uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { | 603 | 9.14k | const Elf_Sym *ESym = getSymbol(Sym); | 604 | 9.14k | | 605 | 9.14k | uint32_t Result = SymbolRef::SF_None; | 606 | 9.14k | | 607 | 9.14k | if (ESym->getBinding() != ELF::STB_LOCAL) | 608 | 3.53k | Result |= SymbolRef::SF_Global; | 609 | 9.14k | | 610 | 9.14k | if (ESym->getBinding() == ELF::STB_WEAK) | 611 | 16 | Result |= SymbolRef::SF_Weak; | 612 | 9.14k | | 613 | 9.14k | if (ESym->st_shndx == ELF::SHN_ABS) | 614 | 235 | Result |= SymbolRef::SF_Absolute; | 615 | 9.14k | | 616 | 9.14k | if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION9.01k ) | 617 | 824 | Result |= SymbolRef::SF_FormatSpecific; | 618 | 9.14k | | 619 | 9.14k | auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); | 620 | 9.14k | if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) | 621 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 622 | 9.14k | auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); | 623 | 9.14k | if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) | 624 | 1 | Result |= SymbolRef::SF_FormatSpecific; | 625 | 9.14k | | 626 | 9.14k | if (EF.getHeader()->e_machine == ELF::EM_ARM) { | 627 | 6.57k | if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { | 628 | 6.57k | StringRef Name = *NameOrErr; | 629 | 6.57k | if (Name.startswith("$d") || Name.startswith("$t")6.36k || | 630 | 6.57k | Name.startswith("$a")4.31k ) | 631 | 2.98k | Result |= SymbolRef::SF_FormatSpecific; | 632 | 6.57k | } else { | 633 | 0 | // TODO: Actually report errors helpfully. | 634 | 0 | consumeError(NameOrErr.takeError()); | 635 | 0 | } | 636 | 6.57k | if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 12.91k ) | 637 | 2.21k | Result |= SymbolRef::SF_Thumb; | 638 | 6.57k | } | 639 | 9.14k | | 640 | 9.14k | if (ESym->st_shndx == ELF::SHN_UNDEF) | 641 | 363 | Result |= SymbolRef::SF_Undefined; | 642 | 9.14k | | 643 | 9.14k | if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON) | 644 | 27 | Result |= SymbolRef::SF_Common; | 645 | 9.14k | | 646 | 9.14k | if (isExportedToOtherDSO(ESym)) | 647 | 3.52k | Result |= SymbolRef::SF_Exported; | 648 | 9.14k | | 649 | 9.14k | if (ESym->getVisibility() == ELF::STV_HIDDEN) | 650 | 163 | Result |= SymbolRef::SF_Hidden; | 651 | 9.14k | | 652 | 9.14k | return Result; | 653 | 9.14k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolFlags(llvm::object::DataRefImpl) const Line | Count | Source | 602 | 1.19k | uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { | 603 | 1.19k | const Elf_Sym *ESym = getSymbol(Sym); | 604 | 1.19k | | 605 | 1.19k | uint32_t Result = SymbolRef::SF_None; | 606 | 1.19k | | 607 | 1.19k | if (ESym->getBinding() != ELF::STB_LOCAL) | 608 | 444 | Result |= SymbolRef::SF_Global; | 609 | 1.19k | | 610 | 1.19k | if (ESym->getBinding() == ELF::STB_WEAK) | 611 | 8 | Result |= SymbolRef::SF_Weak; | 612 | 1.19k | | 613 | 1.19k | if (ESym->st_shndx == ELF::SHN_ABS) | 614 | 70 | Result |= SymbolRef::SF_Absolute; | 615 | 1.19k | | 616 | 1.19k | if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION1.15k ) | 617 | 140 | Result |= SymbolRef::SF_FormatSpecific; | 618 | 1.19k | | 619 | 1.19k | auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); | 620 | 1.19k | if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) | 621 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 622 | 1.19k | auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); | 623 | 1.19k | if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) | 624 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 625 | 1.19k | | 626 | 1.19k | if (EF.getHeader()->e_machine == ELF::EM_ARM) { | 627 | 21 | if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { | 628 | 21 | StringRef Name = *NameOrErr; | 629 | 21 | if (Name.startswith("$d") || Name.startswith("$t") || | 630 | 21 | Name.startswith("$a")19 ) | 631 | 4 | Result |= SymbolRef::SF_FormatSpecific; | 632 | 21 | } else { | 633 | 0 | // TODO: Actually report errors helpfully. | 634 | 0 | consumeError(NameOrErr.takeError()); | 635 | 0 | } | 636 | 21 | if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 10 ) | 637 | 0 | Result |= SymbolRef::SF_Thumb; | 638 | 21 | } | 639 | 1.19k | | 640 | 1.19k | if (ESym->st_shndx == ELF::SHN_UNDEF) | 641 | 79 | Result |= SymbolRef::SF_Undefined; | 642 | 1.19k | | 643 | 1.19k | if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON) | 644 | 17 | Result |= SymbolRef::SF_Common; | 645 | 1.19k | | 646 | 1.19k | if (isExportedToOtherDSO(ESym)) | 647 | 444 | Result |= SymbolRef::SF_Exported; | 648 | 1.19k | | 649 | 1.19k | if (ESym->getVisibility() == ELF::STV_HIDDEN) | 650 | 192 | Result |= SymbolRef::SF_Hidden; | 651 | 1.19k | | 652 | 1.19k | return Result; | 653 | 1.19k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolFlags(llvm::object::DataRefImpl) const Line | Count | Source | 602 | 34.4k | uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { | 603 | 34.4k | const Elf_Sym *ESym = getSymbol(Sym); | 604 | 34.4k | | 605 | 34.4k | uint32_t Result = SymbolRef::SF_None; | 606 | 34.4k | | 607 | 34.4k | if (ESym->getBinding() != ELF::STB_LOCAL) | 608 | 18.5k | Result |= SymbolRef::SF_Global; | 609 | 34.4k | | 610 | 34.4k | if (ESym->getBinding() == ELF::STB_WEAK) | 611 | 4.03k | Result |= SymbolRef::SF_Weak; | 612 | 34.4k | | 613 | 34.4k | if (ESym->st_shndx == ELF::SHN_ABS) | 614 | 1.08k | Result |= SymbolRef::SF_Absolute; | 615 | 34.4k | | 616 | 34.4k | if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION33.6k ) | 617 | 4.07k | Result |= SymbolRef::SF_FormatSpecific; | 618 | 34.4k | | 619 | 34.4k | auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); | 620 | 34.4k | if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) | 621 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 622 | 34.4k | auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); | 623 | 34.4k | if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) | 624 | 6 | Result |= SymbolRef::SF_FormatSpecific; | 625 | 34.4k | | 626 | 34.4k | if (EF.getHeader()->e_machine == ELF::EM_ARM) { | 627 | 40 | if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { | 628 | 40 | StringRef Name = *NameOrErr; | 629 | 40 | if (Name.startswith("$d") || Name.startswith("$t")32 || | 630 | 40 | Name.startswith("$a")24 ) | 631 | 24 | Result |= SymbolRef::SF_FormatSpecific; | 632 | 40 | } else { | 633 | 0 | // TODO: Actually report errors helpfully. | 634 | 0 | consumeError(NameOrErr.takeError()); | 635 | 0 | } | 636 | 40 | if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 10 ) | 637 | 0 | Result |= SymbolRef::SF_Thumb; | 638 | 40 | } | 639 | 34.4k | | 640 | 34.4k | if (ESym->st_shndx == ELF::SHN_UNDEF) | 641 | 1.16k | Result |= SymbolRef::SF_Undefined; | 642 | 34.4k | | 643 | 34.4k | if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON34.4k ) | 644 | 415 | Result |= SymbolRef::SF_Common; | 645 | 34.4k | | 646 | 34.4k | if (isExportedToOtherDSO(ESym)) | 647 | 9.81k | Result |= SymbolRef::SF_Exported; | 648 | 34.4k | | 649 | 34.4k | if (ESym->getVisibility() == ELF::STV_HIDDEN) | 650 | 10.2k | Result |= SymbolRef::SF_Hidden; | 651 | 34.4k | | 652 | 34.4k | return Result; | 653 | 34.4k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolFlags(llvm::object::DataRefImpl) const Line | Count | Source | 602 | 839 | uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { | 603 | 839 | const Elf_Sym *ESym = getSymbol(Sym); | 604 | 839 | | 605 | 839 | uint32_t Result = SymbolRef::SF_None; | 606 | 839 | | 607 | 839 | if (ESym->getBinding() != ELF::STB_LOCAL) | 608 | 326 | Result |= SymbolRef::SF_Global; | 609 | 839 | | 610 | 839 | if (ESym->getBinding() == ELF::STB_WEAK) | 611 | 9 | Result |= SymbolRef::SF_Weak; | 612 | 839 | | 613 | 839 | if (ESym->st_shndx == ELF::SHN_ABS) | 614 | 46 | Result |= SymbolRef::SF_Absolute; | 615 | 839 | | 616 | 839 | if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION807 ) | 617 | 148 | Result |= SymbolRef::SF_FormatSpecific; | 618 | 839 | | 619 | 839 | auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); | 620 | 839 | if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) | 621 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 622 | 839 | auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); | 623 | 839 | if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) | 624 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 625 | 839 | | 626 | 839 | if (EF.getHeader()->e_machine == ELF::EM_ARM) { | 627 | 0 | if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { | 628 | 0 | StringRef Name = *NameOrErr; | 629 | 0 | if (Name.startswith("$d") || Name.startswith("$t") || | 630 | 0 | Name.startswith("$a")) | 631 | 0 | Result |= SymbolRef::SF_FormatSpecific; | 632 | 0 | } else { | 633 | 0 | // TODO: Actually report errors helpfully. | 634 | 0 | consumeError(NameOrErr.takeError()); | 635 | 0 | } | 636 | 0 | if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1) | 637 | 0 | Result |= SymbolRef::SF_Thumb; | 638 | 0 | } | 639 | 839 | | 640 | 839 | if (ESym->st_shndx == ELF::SHN_UNDEF) | 641 | 47 | Result |= SymbolRef::SF_Undefined; | 642 | 839 | | 643 | 839 | if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON) | 644 | 9 | Result |= SymbolRef::SF_Common; | 645 | 839 | | 646 | 839 | if (isExportedToOtherDSO(ESym)) | 647 | 326 | Result |= SymbolRef::SF_Exported; | 648 | 839 | | 649 | 839 | if (ESym->getVisibility() == ELF::STV_HIDDEN) | 650 | 98 | Result |= SymbolRef::SF_Hidden; | 651 | 839 | | 652 | 839 | return Result; | 653 | 839 | } |
|
654 | | |
655 | | template <class ELFT> |
656 | | Expected<section_iterator> |
657 | | ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym, |
658 | 28.2k | const Elf_Shdr *SymTab) const { |
659 | 28.2k | auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); |
660 | 28.2k | if (!ESecOrErr) |
661 | 0 | return ESecOrErr.takeError(); |
662 | 28.2k | |
663 | 28.2k | const Elf_Shdr *ESec = *ESecOrErr; |
664 | 28.2k | if (!ESec) |
665 | 2.44k | return section_end(); |
666 | 25.7k | |
667 | 25.7k | DataRefImpl Sec; |
668 | 25.7k | Sec.p = reinterpret_cast<intptr_t>(ESec); |
669 | 25.7k | return section_iterator(SectionRef(Sec, this)); |
670 | 25.7k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*) const Line | Count | Source | 658 | 8.62k | const Elf_Shdr *SymTab) const { | 659 | 8.62k | auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 660 | 8.62k | if (!ESecOrErr) | 661 | 0 | return ESecOrErr.takeError(); | 662 | 8.62k | | 663 | 8.62k | const Elf_Shdr *ESec = *ESecOrErr; | 664 | 8.62k | if (!ESec) | 665 | 465 | return section_end(); | 666 | 8.16k | | 667 | 8.16k | DataRefImpl Sec; | 668 | 8.16k | Sec.p = reinterpret_cast<intptr_t>(ESec); | 669 | 8.16k | return section_iterator(SectionRef(Sec, this)); | 670 | 8.16k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*) const Line | Count | Source | 658 | 920 | const Elf_Shdr *SymTab) const { | 659 | 920 | auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 660 | 920 | if (!ESecOrErr) | 661 | 0 | return ESecOrErr.takeError(); | 662 | 920 | | 663 | 920 | const Elf_Shdr *ESec = *ESecOrErr; | 664 | 920 | if (!ESec) | 665 | 130 | return section_end(); | 666 | 790 | | 667 | 790 | DataRefImpl Sec; | 668 | 790 | Sec.p = reinterpret_cast<intptr_t>(ESec); | 669 | 790 | return section_iterator(SectionRef(Sec, this)); | 670 | 790 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*) const Line | Count | Source | 658 | 18.1k | const Elf_Shdr *SymTab) const { | 659 | 18.1k | auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 660 | 18.1k | if (!ESecOrErr) | 661 | 0 | return ESecOrErr.takeError(); | 662 | 18.1k | | 663 | 18.1k | const Elf_Shdr *ESec = *ESecOrErr; | 664 | 18.1k | if (!ESec) | 665 | 1.77k | return section_end(); | 666 | 16.3k | | 667 | 16.3k | DataRefImpl Sec; | 668 | 16.3k | Sec.p = reinterpret_cast<intptr_t>(ESec); | 669 | 16.3k | return section_iterator(SectionRef(Sec, this)); | 670 | 16.3k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*) const Line | Count | Source | 658 | 582 | const Elf_Shdr *SymTab) const { | 659 | 582 | auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); | 660 | 582 | if (!ESecOrErr) | 661 | 0 | return ESecOrErr.takeError(); | 662 | 582 | | 663 | 582 | const Elf_Shdr *ESec = *ESecOrErr; | 664 | 582 | if (!ESec) | 665 | 72 | return section_end(); | 666 | 510 | | 667 | 510 | DataRefImpl Sec; | 668 | 510 | Sec.p = reinterpret_cast<intptr_t>(ESec); | 669 | 510 | return section_iterator(SectionRef(Sec, this)); | 670 | 510 | } |
|
671 | | |
672 | | template <class ELFT> |
673 | | Expected<section_iterator> |
674 | 28.2k | ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { |
675 | 28.2k | const Elf_Sym *Sym = getSymbol(Symb); |
676 | 28.2k | auto SymTabOrErr = EF.getSection(Symb.d.a); |
677 | 28.2k | if (!SymTabOrErr) |
678 | 0 | return SymTabOrErr.takeError(); |
679 | 28.2k | const Elf_Shdr *SymTab = *SymTabOrErr; |
680 | 28.2k | return getSymbolSection(Sym, SymTab); |
681 | 28.2k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbolSection(llvm::object::DataRefImpl) const Line | Count | Source | 674 | 8.62k | ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { | 675 | 8.62k | const Elf_Sym *Sym = getSymbol(Symb); | 676 | 8.62k | auto SymTabOrErr = EF.getSection(Symb.d.a); | 677 | 8.62k | if (!SymTabOrErr) | 678 | 0 | return SymTabOrErr.takeError(); | 679 | 8.62k | const Elf_Shdr *SymTab = *SymTabOrErr; | 680 | 8.62k | return getSymbolSection(Sym, SymTab); | 681 | 8.62k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbolSection(llvm::object::DataRefImpl) const Line | Count | Source | 674 | 920 | ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { | 675 | 920 | const Elf_Sym *Sym = getSymbol(Symb); | 676 | 920 | auto SymTabOrErr = EF.getSection(Symb.d.a); | 677 | 920 | if (!SymTabOrErr) | 678 | 0 | return SymTabOrErr.takeError(); | 679 | 920 | const Elf_Shdr *SymTab = *SymTabOrErr; | 680 | 920 | return getSymbolSection(Sym, SymTab); | 681 | 920 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbolSection(llvm::object::DataRefImpl) const Line | Count | Source | 674 | 18.1k | ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { | 675 | 18.1k | const Elf_Sym *Sym = getSymbol(Symb); | 676 | 18.1k | auto SymTabOrErr = EF.getSection(Symb.d.a); | 677 | 18.1k | if (!SymTabOrErr) | 678 | 0 | return SymTabOrErr.takeError(); | 679 | 18.1k | const Elf_Shdr *SymTab = *SymTabOrErr; | 680 | 18.1k | return getSymbolSection(Sym, SymTab); | 681 | 18.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbolSection(llvm::object::DataRefImpl) const Line | Count | Source | 674 | 582 | ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { | 675 | 582 | const Elf_Sym *Sym = getSymbol(Symb); | 676 | 582 | auto SymTabOrErr = EF.getSection(Symb.d.a); | 677 | 582 | if (!SymTabOrErr) | 678 | 0 | return SymTabOrErr.takeError(); | 679 | 582 | const Elf_Shdr *SymTab = *SymTabOrErr; | 680 | 582 | return getSymbolSection(Sym, SymTab); | 681 | 582 | } |
|
682 | | |
683 | | template <class ELFT> |
684 | 142k | void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { |
685 | 142k | const Elf_Shdr *ESec = getSection(Sec); |
686 | 142k | Sec = toDRI(++ESec); |
687 | 142k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::moveSectionNext(llvm::object::DataRefImpl&) const Line | Count | Source | 684 | 15.0k | void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { | 685 | 15.0k | const Elf_Shdr *ESec = getSection(Sec); | 686 | 15.0k | Sec = toDRI(++ESec); | 687 | 15.0k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::moveSectionNext(llvm::object::DataRefImpl&) const Line | Count | Source | 684 | 5.62k | void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { | 685 | 5.62k | const Elf_Shdr *ESec = getSection(Sec); | 686 | 5.62k | Sec = toDRI(++ESec); | 687 | 5.62k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::moveSectionNext(llvm::object::DataRefImpl&) const Line | Count | Source | 684 | 118k | void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { | 685 | 118k | const Elf_Shdr *ESec = getSection(Sec); | 686 | 118k | Sec = toDRI(++ESec); | 687 | 118k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::moveSectionNext(llvm::object::DataRefImpl&) const Line | Count | Source | 684 | 3.76k | void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { | 685 | 3.76k | const Elf_Shdr *ESec = getSection(Sec); | 686 | 3.76k | Sec = toDRI(++ESec); | 687 | 3.76k | } |
|
688 | | |
689 | | template <class ELFT> |
690 | 121k | Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { |
691 | 121k | return EF.getSectionName(&*getSection(Sec)); |
692 | 121k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionName(llvm::object::DataRefImpl) const Line | Count | Source | 690 | 8.33k | Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { | 691 | 8.33k | return EF.getSectionName(&*getSection(Sec)); | 692 | 8.33k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionName(llvm::object::DataRefImpl) const Line | Count | Source | 690 | 2.62k | Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { | 691 | 2.62k | return EF.getSectionName(&*getSection(Sec)); | 692 | 2.62k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionName(llvm::object::DataRefImpl) const Line | Count | Source | 690 | 109k | Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { | 691 | 109k | return EF.getSectionName(&*getSection(Sec)); | 692 | 109k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionName(llvm::object::DataRefImpl) const Line | Count | Source | 690 | 1.89k | Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { | 691 | 1.89k | return EF.getSectionName(&*getSection(Sec)); | 692 | 1.89k | } |
|
693 | | |
694 | | template <class ELFT> |
695 | 27.1k | uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { |
696 | 27.1k | return getSection(Sec)->sh_addr; |
697 | 27.1k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionAddress(llvm::object::DataRefImpl) const Line | Count | Source | 695 | 5.30k | uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { | 696 | 5.30k | return getSection(Sec)->sh_addr; | 697 | 5.30k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionAddress(llvm::object::DataRefImpl) const Line | Count | Source | 695 | 1.64k | uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { | 696 | 1.64k | return getSection(Sec)->sh_addr; | 697 | 1.64k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionAddress(llvm::object::DataRefImpl) const Line | Count | Source | 695 | 19.2k | uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { | 696 | 19.2k | return getSection(Sec)->sh_addr; | 697 | 19.2k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionAddress(llvm::object::DataRefImpl) const Line | Count | Source | 695 | 1.00k | uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { | 696 | 1.00k | return getSection(Sec)->sh_addr; | 697 | 1.00k | } |
|
698 | | |
699 | | template <class ELFT> |
700 | 66.6k | uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { |
701 | 66.6k | auto SectionsOrErr = EF.sections(); |
702 | 66.6k | handleAllErrors(std::move(SectionsOrErr.takeError()), |
703 | 66.6k | [](const ErrorInfoBase &) { |
704 | 0 | llvm_unreachable("unable to get section index"); |
705 | 0 | }); Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionIndex(llvm::object::DataRefImpl) const::'lambda'(llvm::ErrorInfoBase const&)::operator()(llvm::ErrorInfoBase const&) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionIndex(llvm::object::DataRefImpl) const::'lambda'(llvm::ErrorInfoBase const&)::operator()(llvm::ErrorInfoBase const&) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionIndex(llvm::object::DataRefImpl) const::'lambda'(llvm::ErrorInfoBase const&)::operator()(llvm::ErrorInfoBase const&) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionIndex(llvm::object::DataRefImpl) const::'lambda'(llvm::ErrorInfoBase const&)::operator()(llvm::ErrorInfoBase const&) const |
706 | 66.6k | const Elf_Shdr *First = SectionsOrErr->begin(); |
707 | 66.6k | return getSection(Sec) - First; |
708 | 66.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionIndex(llvm::object::DataRefImpl) const Line | Count | Source | 700 | 35.1k | uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { | 701 | 35.1k | auto SectionsOrErr = EF.sections(); | 702 | 35.1k | handleAllErrors(std::move(SectionsOrErr.takeError()), | 703 | 35.1k | [](const ErrorInfoBase &) { | 704 | 35.1k | llvm_unreachable("unable to get section index"); | 705 | 35.1k | }); | 706 | 35.1k | const Elf_Shdr *First = SectionsOrErr->begin(); | 707 | 35.1k | return getSection(Sec) - First; | 708 | 35.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionIndex(llvm::object::DataRefImpl) const Line | Count | Source | 700 | 1.70k | uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { | 701 | 1.70k | auto SectionsOrErr = EF.sections(); | 702 | 1.70k | handleAllErrors(std::move(SectionsOrErr.takeError()), | 703 | 1.70k | [](const ErrorInfoBase &) { | 704 | 1.70k | llvm_unreachable("unable to get section index"); | 705 | 1.70k | }); | 706 | 1.70k | const Elf_Shdr *First = SectionsOrErr->begin(); | 707 | 1.70k | return getSection(Sec) - First; | 708 | 1.70k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionIndex(llvm::object::DataRefImpl) const Line | Count | Source | 700 | 28.6k | uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { | 701 | 28.6k | auto SectionsOrErr = EF.sections(); | 702 | 28.6k | handleAllErrors(std::move(SectionsOrErr.takeError()), | 703 | 28.6k | [](const ErrorInfoBase &) { | 704 | 28.6k | llvm_unreachable("unable to get section index"); | 705 | 28.6k | }); | 706 | 28.6k | const Elf_Shdr *First = SectionsOrErr->begin(); | 707 | 28.6k | return getSection(Sec) - First; | 708 | 28.6k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionIndex(llvm::object::DataRefImpl) const Line | Count | Source | 700 | 1.23k | uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { | 701 | 1.23k | auto SectionsOrErr = EF.sections(); | 702 | 1.23k | handleAllErrors(std::move(SectionsOrErr.takeError()), | 703 | 1.23k | [](const ErrorInfoBase &) { | 704 | 1.23k | llvm_unreachable("unable to get section index"); | 705 | 1.23k | }); | 706 | 1.23k | const Elf_Shdr *First = SectionsOrErr->begin(); | 707 | 1.23k | return getSection(Sec) - First; | 708 | 1.23k | } |
|
709 | | |
710 | | template <class ELFT> |
711 | 197k | uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { |
712 | 197k | return getSection(Sec)->sh_size; |
713 | 197k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionSize(llvm::object::DataRefImpl) const Line | Count | Source | 711 | 1.44k | uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { | 712 | 1.44k | return getSection(Sec)->sh_size; | 713 | 1.44k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionSize(llvm::object::DataRefImpl) const Line | Count | Source | 711 | 581 | uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { | 712 | 581 | return getSection(Sec)->sh_size; | 713 | 581 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionSize(llvm::object::DataRefImpl) const Line | Count | Source | 711 | 195k | uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { | 712 | 195k | return getSection(Sec)->sh_size; | 713 | 195k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionSize(llvm::object::DataRefImpl) const Line | Count | Source | 711 | 377 | uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { | 712 | 377 | return getSection(Sec)->sh_size; | 713 | 377 | } |
|
714 | | |
715 | | template <class ELFT> |
716 | | Expected<ArrayRef<uint8_t>> |
717 | 16.1k | ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { |
718 | 16.1k | const Elf_Shdr *EShdr = getSection(Sec); |
719 | 16.1k | if (std::error_code EC = |
720 | 16 | checkOffset(getMemoryBufferRef(), |
721 | 16 | (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) |
722 | 16 | return errorCodeToError(EC); |
723 | 16.1k | return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, |
724 | 16.1k | EShdr->sh_size); |
725 | 16.1k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionContents(llvm::object::DataRefImpl) const Line | Count | Source | 717 | 2.09k | ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { | 718 | 2.09k | const Elf_Shdr *EShdr = getSection(Sec); | 719 | 2.09k | if (std::error_code EC = | 720 | 16 | checkOffset(getMemoryBufferRef(), | 721 | 16 | (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) | 722 | 16 | return errorCodeToError(EC); | 723 | 2.08k | return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, | 724 | 2.08k | EShdr->sh_size); | 725 | 2.08k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionContents(llvm::object::DataRefImpl) const Line | Count | Source | 717 | 681 | ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { | 718 | 681 | const Elf_Shdr *EShdr = getSection(Sec); | 719 | 681 | if (std::error_code EC = | 720 | 0 | checkOffset(getMemoryBufferRef(), | 721 | 0 | (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) | 722 | 0 | return errorCodeToError(EC); | 723 | 681 | return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, | 724 | 681 | EShdr->sh_size); | 725 | 681 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionContents(llvm::object::DataRefImpl) const Line | Count | Source | 717 | 12.8k | ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { | 718 | 12.8k | const Elf_Shdr *EShdr = getSection(Sec); | 719 | 12.8k | if (std::error_code EC = | 720 | 0 | checkOffset(getMemoryBufferRef(), | 721 | 0 | (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) | 722 | 0 | return errorCodeToError(EC); | 723 | 12.8k | return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, | 724 | 12.8k | EShdr->sh_size); | 725 | 12.8k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionContents(llvm::object::DataRefImpl) const Line | Count | Source | 717 | 539 | ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { | 718 | 539 | const Elf_Shdr *EShdr = getSection(Sec); | 719 | 539 | if (std::error_code EC = | 720 | 0 | checkOffset(getMemoryBufferRef(), | 721 | 0 | (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) | 722 | 0 | return errorCodeToError(EC); | 723 | 539 | return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, | 724 | 539 | EShdr->sh_size); | 725 | 539 | } |
|
726 | | |
727 | | template <class ELFT> |
728 | 1.00k | uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { |
729 | 1.00k | return getSection(Sec)->sh_addralign; |
730 | 1.00k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSectionAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 728 | 166 | uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { | 729 | 166 | return getSection(Sec)->sh_addralign; | 730 | 166 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSectionAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 728 | 160 | uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { | 729 | 160 | return getSection(Sec)->sh_addralign; | 730 | 160 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSectionAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 728 | 502 | uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { | 729 | 502 | return getSection(Sec)->sh_addralign; | 730 | 502 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSectionAlignment(llvm::object::DataRefImpl) const Line | Count | Source | 728 | 176 | uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { | 729 | 176 | return getSection(Sec)->sh_addralign; | 730 | 176 | } |
|
731 | | |
732 | | template <class ELFT> |
733 | 10.6k | bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { |
734 | 10.6k | return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; |
735 | 10.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isSectionCompressed(llvm::object::DataRefImpl) const Line | Count | Source | 733 | 829 | bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { | 734 | 829 | return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; | 735 | 829 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isSectionCompressed(llvm::object::DataRefImpl) const Line | Count | Source | 733 | 232 | bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { | 734 | 232 | return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; | 735 | 232 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isSectionCompressed(llvm::object::DataRefImpl) const Line | Count | Source | 733 | 9.29k | bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { | 734 | 9.29k | return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; | 735 | 9.29k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isSectionCompressed(llvm::object::DataRefImpl) const Line | Count | Source | 733 | 288 | bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { | 734 | 288 | return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; | 735 | 288 | } |
|
736 | | |
737 | | template <class ELFT> |
738 | 23.8k | bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { |
739 | 23.8k | return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; |
740 | 23.8k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isSectionText(llvm::object::DataRefImpl) const Line | Count | Source | 738 | 6.42k | bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { | 739 | 6.42k | return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; | 740 | 6.42k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isSectionText(llvm::object::DataRefImpl) const Line | Count | Source | 738 | 1.70k | bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { | 739 | 1.70k | return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; | 740 | 1.70k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isSectionText(llvm::object::DataRefImpl) const Line | Count | Source | 738 | 14.6k | bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { | 739 | 14.6k | return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; | 740 | 14.6k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isSectionText(llvm::object::DataRefImpl) const Line | Count | Source | 738 | 1.01k | bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { | 739 | 1.01k | return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; | 740 | 1.01k | } |
|
741 | | |
742 | | template <class ELFT> |
743 | 1.36k | bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const { |
744 | 1.36k | const Elf_Shdr *EShdr = getSection(Sec); |
745 | 1.36k | return EShdr->sh_type == ELF::SHT_PROGBITS && |
746 | 1.36k | EShdr->sh_flags & ELF::SHF_ALLOC565 && |
747 | 1.36k | !(EShdr->sh_flags & ELF::SHF_EXECINSTR)368 ; |
748 | 1.36k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isSectionData(llvm::object::DataRefImpl) const Line | Count | Source | 743 | 28 | bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const { | 744 | 28 | const Elf_Shdr *EShdr = getSection(Sec); | 745 | 28 | return EShdr->sh_type == ELF::SHT_PROGBITS && | 746 | 28 | EShdr->sh_flags & ELF::SHF_ALLOC10 && | 747 | 28 | !(EShdr->sh_flags & ELF::SHF_EXECINSTR)7 ; | 748 | 28 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isSectionData(llvm::object::DataRefImpl) const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isSectionData(llvm::object::DataRefImpl) const Line | Count | Source | 743 | 1.32k | bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const { | 744 | 1.32k | const Elf_Shdr *EShdr = getSection(Sec); | 745 | 1.32k | return EShdr->sh_type == ELF::SHT_PROGBITS && | 746 | 1.32k | EShdr->sh_flags & ELF::SHF_ALLOC550 && | 747 | 1.32k | !(EShdr->sh_flags & ELF::SHF_EXECINSTR)357 ; | 748 | 1.32k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isSectionData(llvm::object::DataRefImpl) const Line | Count | Source | 743 | 19 | bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const { | 744 | 19 | const Elf_Shdr *EShdr = getSection(Sec); | 745 | 19 | return EShdr->sh_type == ELF::SHT_PROGBITS && | 746 | 19 | EShdr->sh_flags & ELF::SHF_ALLOC5 && | 747 | 19 | !(EShdr->sh_flags & ELF::SHF_EXECINSTR)4 ; | 748 | 19 | } |
|
749 | | |
750 | | template <class ELFT> |
751 | 14.3k | bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { |
752 | 14.3k | const Elf_Shdr *EShdr = getSection(Sec); |
753 | 14.3k | return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && |
754 | 14.3k | EShdr->sh_type == ELF::SHT_NOBITS4.43k ; |
755 | 14.3k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isSectionBSS(llvm::object::DataRefImpl) const Line | Count | Source | 751 | 1.35k | bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { | 752 | 1.35k | const Elf_Shdr *EShdr = getSection(Sec); | 753 | 1.35k | return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && | 754 | 1.35k | EShdr->sh_type == ELF::SHT_NOBITS431 ; | 755 | 1.35k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isSectionBSS(llvm::object::DataRefImpl) const Line | Count | Source | 751 | 485 | bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { | 752 | 485 | const Elf_Shdr *EShdr = getSection(Sec); | 753 | 485 | return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && | 754 | 485 | EShdr->sh_type == ELF::SHT_NOBITS204 ; | 755 | 485 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isSectionBSS(llvm::object::DataRefImpl) const Line | Count | Source | 751 | 12.1k | bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { | 752 | 12.1k | const Elf_Shdr *EShdr = getSection(Sec); | 753 | 12.1k | return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && | 754 | 12.1k | EShdr->sh_type == ELF::SHT_NOBITS3.66k ; | 755 | 12.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isSectionBSS(llvm::object::DataRefImpl) const Line | Count | Source | 751 | 395 | bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { | 752 | 395 | const Elf_Shdr *EShdr = getSection(Sec); | 753 | 395 | return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && | 754 | 395 | EShdr->sh_type == ELF::SHT_NOBITS135 ; | 755 | 395 | } |
|
756 | | |
757 | | template <class ELFT> |
758 | | std::vector<SectionRef> |
759 | 1 | ELFObjectFile<ELFT>::dynamic_relocation_sections() const { |
760 | 1 | std::vector<SectionRef> Res; |
761 | 1 | std::vector<uintptr_t> Offsets; |
762 | 1 | |
763 | 1 | auto SectionsOrErr = EF.sections(); |
764 | 1 | if (!SectionsOrErr) |
765 | 0 | return Res; |
766 | 1 | |
767 | 12 | for (const Elf_Shdr &Sec : *SectionsOrErr)1 { |
768 | 12 | if (Sec.sh_type != ELF::SHT_DYNAMIC) |
769 | 11 | continue; |
770 | 1 | Elf_Dyn *Dynamic = |
771 | 1 | reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset); |
772 | 10 | for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++9 ) { |
773 | 9 | if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA8 || |
774 | 9 | Dynamic->d_tag == ELF::DT_JMPREL7 ) { |
775 | 3 | Offsets.push_back(Dynamic->d_un.d_val); |
776 | 3 | } |
777 | 9 | } |
778 | 1 | } |
779 | 12 | for (const Elf_Shdr &Sec : *SectionsOrErr) { |
780 | 12 | if (is_contained(Offsets, Sec.sh_addr)) |
781 | 3 | Res.emplace_back(toDRI(&Sec), this); |
782 | 12 | } |
783 | 1 | return Res; |
784 | 1 | } Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::dynamic_relocation_sections() const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::dynamic_relocation_sections() const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::dynamic_relocation_sections() const Line | Count | Source | 759 | 1 | ELFObjectFile<ELFT>::dynamic_relocation_sections() const { | 760 | 1 | std::vector<SectionRef> Res; | 761 | 1 | std::vector<uintptr_t> Offsets; | 762 | 1 | | 763 | 1 | auto SectionsOrErr = EF.sections(); | 764 | 1 | if (!SectionsOrErr) | 765 | 0 | return Res; | 766 | 1 | | 767 | 12 | for (const Elf_Shdr &Sec : *SectionsOrErr)1 { | 768 | 12 | if (Sec.sh_type != ELF::SHT_DYNAMIC) | 769 | 11 | continue; | 770 | 1 | Elf_Dyn *Dynamic = | 771 | 1 | reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset); | 772 | 10 | for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++9 ) { | 773 | 9 | if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA8 || | 774 | 9 | Dynamic->d_tag == ELF::DT_JMPREL7 ) { | 775 | 3 | Offsets.push_back(Dynamic->d_un.d_val); | 776 | 3 | } | 777 | 9 | } | 778 | 1 | } | 779 | 12 | for (const Elf_Shdr &Sec : *SectionsOrErr) { | 780 | 12 | if (is_contained(Offsets, Sec.sh_addr)) | 781 | 3 | Res.emplace_back(toDRI(&Sec), this); | 782 | 12 | } | 783 | 1 | return Res; | 784 | 1 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::dynamic_relocation_sections() const |
785 | | |
786 | | template <class ELFT> |
787 | 19.4k | bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { |
788 | 19.4k | return getSection(Sec)->sh_type == ELF::SHT_NOBITS; |
789 | 19.4k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isSectionVirtual(llvm::object::DataRefImpl) const Line | Count | Source | 787 | 3.66k | bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { | 788 | 3.66k | return getSection(Sec)->sh_type == ELF::SHT_NOBITS; | 789 | 3.66k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isSectionVirtual(llvm::object::DataRefImpl) const Line | Count | Source | 787 | 740 | bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { | 788 | 740 | return getSection(Sec)->sh_type == ELF::SHT_NOBITS; | 789 | 740 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isSectionVirtual(llvm::object::DataRefImpl) const Line | Count | Source | 787 | 14.4k | bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { | 788 | 14.4k | return getSection(Sec)->sh_type == ELF::SHT_NOBITS; | 789 | 14.4k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isSectionVirtual(llvm::object::DataRefImpl) const Line | Count | Source | 787 | 620 | bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { | 788 | 620 | return getSection(Sec)->sh_type == ELF::SHT_NOBITS; | 789 | 620 | } |
|
790 | | |
791 | | template <class ELFT> |
792 | 78 | bool ELFObjectFile<ELFT>::isBerkeleyText(DataRefImpl Sec) const { |
793 | 78 | return getSection(Sec)->sh_flags & ELF::SHF_ALLOC && |
794 | 78 | (32 getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR32 || |
795 | 32 | !(getSection(Sec)->sh_flags & ELF::SHF_WRITE)20 ); |
796 | 78 | } Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isBerkeleyText(llvm::object::DataRefImpl) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isBerkeleyText(llvm::object::DataRefImpl) const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isBerkeleyText(llvm::object::DataRefImpl) const Line | Count | Source | 792 | 78 | bool ELFObjectFile<ELFT>::isBerkeleyText(DataRefImpl Sec) const { | 793 | 78 | return getSection(Sec)->sh_flags & ELF::SHF_ALLOC && | 794 | 78 | (32 getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR32 || | 795 | 32 | !(getSection(Sec)->sh_flags & ELF::SHF_WRITE)20 ); | 796 | 78 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isBerkeleyText(llvm::object::DataRefImpl) const |
797 | | |
798 | | template <class ELFT> |
799 | 39 | bool ELFObjectFile<ELFT>::isBerkeleyData(DataRefImpl Sec) const { |
800 | 39 | const Elf_Shdr *EShdr = getSection(Sec); |
801 | 39 | return !isBerkeleyText(Sec) && EShdr->sh_type != ELF::SHT_NOBITS31 && |
802 | 39 | EShdr->sh_flags & ELF::SHF_ALLOC28 ; |
803 | 39 | } Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isBerkeleyData(llvm::object::DataRefImpl) const Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isBerkeleyData(llvm::object::DataRefImpl) const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isBerkeleyData(llvm::object::DataRefImpl) const Line | Count | Source | 799 | 39 | bool ELFObjectFile<ELFT>::isBerkeleyData(DataRefImpl Sec) const { | 800 | 39 | const Elf_Shdr *EShdr = getSection(Sec); | 801 | 39 | return !isBerkeleyText(Sec) && EShdr->sh_type != ELF::SHT_NOBITS31 && | 802 | 39 | EShdr->sh_flags & ELF::SHF_ALLOC28 ; | 803 | 39 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isBerkeleyData(llvm::object::DataRefImpl) const |
804 | | |
805 | | template <class ELFT> |
806 | | relocation_iterator |
807 | 8.19k | ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { |
808 | 8.19k | DataRefImpl RelData; |
809 | 8.19k | auto SectionsOrErr = EF.sections(); |
810 | 8.19k | if (!SectionsOrErr) |
811 | 0 | return relocation_iterator(RelocationRef()); |
812 | 8.19k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); |
813 | 8.19k | RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; |
814 | 8.19k | RelData.d.b = 0; |
815 | 8.19k | return relocation_iterator(RelocationRef(RelData, this)); |
816 | 8.19k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::section_rel_begin(llvm::object::DataRefImpl) const Line | Count | Source | 807 | 1.11k | ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { | 808 | 1.11k | DataRefImpl RelData; | 809 | 1.11k | auto SectionsOrErr = EF.sections(); | 810 | 1.11k | if (!SectionsOrErr) | 811 | 0 | return relocation_iterator(RelocationRef()); | 812 | 1.11k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 813 | 1.11k | RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; | 814 | 1.11k | RelData.d.b = 0; | 815 | 1.11k | return relocation_iterator(RelocationRef(RelData, this)); | 816 | 1.11k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::section_rel_begin(llvm::object::DataRefImpl) const Line | Count | Source | 807 | 258 | ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { | 808 | 258 | DataRefImpl RelData; | 809 | 258 | auto SectionsOrErr = EF.sections(); | 810 | 258 | if (!SectionsOrErr) | 811 | 0 | return relocation_iterator(RelocationRef()); | 812 | 258 | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 813 | 258 | RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; | 814 | 258 | RelData.d.b = 0; | 815 | 258 | return relocation_iterator(RelocationRef(RelData, this)); | 816 | 258 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::section_rel_begin(llvm::object::DataRefImpl) const Line | Count | Source | 807 | 6.50k | ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { | 808 | 6.50k | DataRefImpl RelData; | 809 | 6.50k | auto SectionsOrErr = EF.sections(); | 810 | 6.50k | if (!SectionsOrErr) | 811 | 0 | return relocation_iterator(RelocationRef()); | 812 | 6.50k | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 813 | 6.50k | RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; | 814 | 6.50k | RelData.d.b = 0; | 815 | 6.50k | return relocation_iterator(RelocationRef(RelData, this)); | 816 | 6.50k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::section_rel_begin(llvm::object::DataRefImpl) const Line | Count | Source | 807 | 324 | ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { | 808 | 324 | DataRefImpl RelData; | 809 | 324 | auto SectionsOrErr = EF.sections(); | 810 | 324 | if (!SectionsOrErr) | 811 | 0 | return relocation_iterator(RelocationRef()); | 812 | 324 | uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); | 813 | 324 | RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; | 814 | 324 | RelData.d.b = 0; | 815 | 324 | return relocation_iterator(RelocationRef(RelData, this)); | 816 | 324 | } |
|
817 | | |
818 | | template <class ELFT> |
819 | | relocation_iterator |
820 | 4.09k | ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { |
821 | 4.09k | const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); |
822 | 4.09k | relocation_iterator Begin = section_rel_begin(Sec); |
823 | 4.09k | if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL1.10k ) |
824 | 628 | return Begin; |
825 | 3.47k | DataRefImpl RelData = Begin->getRawDataRefImpl(); |
826 | 3.47k | const Elf_Shdr *RelSec = getRelSection(RelData); |
827 | 3.47k | |
828 | 3.47k | // Error check sh_link here so that getRelocationSymbol can just use it. |
829 | 3.47k | auto SymSecOrErr = EF.getSection(RelSec->sh_link); |
830 | 3.47k | if (!SymSecOrErr) |
831 | 0 | report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); |
832 | 3.47k | |
833 | 3.47k | RelData.d.b += S->sh_size / S->sh_entsize; |
834 | 3.47k | return relocation_iterator(RelocationRef(RelData, this)); |
835 | 3.47k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::section_rel_end(llvm::object::DataRefImpl) const Line | Count | Source | 820 | 555 | ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { | 821 | 555 | const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); | 822 | 555 | relocation_iterator Begin = section_rel_begin(Sec); | 823 | 555 | if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL470 ) | 824 | 140 | return Begin; | 825 | 415 | DataRefImpl RelData = Begin->getRawDataRefImpl(); | 826 | 415 | const Elf_Shdr *RelSec = getRelSection(RelData); | 827 | 415 | | 828 | 415 | // Error check sh_link here so that getRelocationSymbol can just use it. | 829 | 415 | auto SymSecOrErr = EF.getSection(RelSec->sh_link); | 830 | 415 | if (!SymSecOrErr) | 831 | 0 | report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); | 832 | 415 | | 833 | 415 | RelData.d.b += S->sh_size / S->sh_entsize; | 834 | 415 | return relocation_iterator(RelocationRef(RelData, this)); | 835 | 415 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::section_rel_end(llvm::object::DataRefImpl) const Line | Count | Source | 820 | 129 | ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { | 821 | 129 | const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); | 822 | 129 | relocation_iterator Begin = section_rel_begin(Sec); | 823 | 129 | if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL92 ) | 824 | 12 | return Begin; | 825 | 117 | DataRefImpl RelData = Begin->getRawDataRefImpl(); | 826 | 117 | const Elf_Shdr *RelSec = getRelSection(RelData); | 827 | 117 | | 828 | 117 | // Error check sh_link here so that getRelocationSymbol can just use it. | 829 | 117 | auto SymSecOrErr = EF.getSection(RelSec->sh_link); | 830 | 117 | if (!SymSecOrErr) | 831 | 0 | report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); | 832 | 117 | | 833 | 117 | RelData.d.b += S->sh_size / S->sh_entsize; | 834 | 117 | return relocation_iterator(RelocationRef(RelData, this)); | 835 | 117 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::section_rel_end(llvm::object::DataRefImpl) const Line | Count | Source | 820 | 3.25k | ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { | 821 | 3.25k | const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); | 822 | 3.25k | relocation_iterator Begin = section_rel_begin(Sec); | 823 | 3.25k | if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL491 ) | 824 | 450 | return Begin; | 825 | 2.80k | DataRefImpl RelData = Begin->getRawDataRefImpl(); | 826 | 2.80k | const Elf_Shdr *RelSec = getRelSection(RelData); | 827 | 2.80k | | 828 | 2.80k | // Error check sh_link here so that getRelocationSymbol can just use it. | 829 | 2.80k | auto SymSecOrErr = EF.getSection(RelSec->sh_link); | 830 | 2.80k | if (!SymSecOrErr) | 831 | 0 | report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); | 832 | 2.80k | | 833 | 2.80k | RelData.d.b += S->sh_size / S->sh_entsize; | 834 | 2.80k | return relocation_iterator(RelocationRef(RelData, this)); | 835 | 2.80k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::section_rel_end(llvm::object::DataRefImpl) const Line | Count | Source | 820 | 162 | ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { | 821 | 162 | const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); | 822 | 162 | relocation_iterator Begin = section_rel_begin(Sec); | 823 | 162 | if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL48 ) | 824 | 26 | return Begin; | 825 | 136 | DataRefImpl RelData = Begin->getRawDataRefImpl(); | 826 | 136 | const Elf_Shdr *RelSec = getRelSection(RelData); | 827 | 136 | | 828 | 136 | // Error check sh_link here so that getRelocationSymbol can just use it. | 829 | 136 | auto SymSecOrErr = EF.getSection(RelSec->sh_link); | 830 | 136 | if (!SymSecOrErr) | 831 | 0 | report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); | 832 | 136 | | 833 | 136 | RelData.d.b += S->sh_size / S->sh_entsize; | 834 | 136 | return relocation_iterator(RelocationRef(RelData, this)); | 835 | 136 | } |
|
836 | | |
837 | | template <class ELFT> |
838 | | section_iterator |
839 | 17.5k | ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { |
840 | 17.5k | if (EF.getHeader()->e_type != ELF::ET_REL) |
841 | 3.36k | return section_end(); |
842 | 14.1k | |
843 | 14.1k | const Elf_Shdr *EShdr = getSection(Sec); |
844 | 14.1k | uintX_t Type = EShdr->sh_type; |
845 | 14.1k | if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA13.7k ) |
846 | 11.2k | return section_end(); |
847 | 2.91k | |
848 | 2.91k | auto R = EF.getSection(EShdr->sh_info); |
849 | 2.91k | if (!R) |
850 | 1 | report_fatal_error(errorToErrorCode(R.takeError()).message()); |
851 | 2.91k | return section_iterator(SectionRef(toDRI(*R), this)); |
852 | 2.91k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocatedSection(llvm::object::DataRefImpl) const Line | Count | Source | 839 | 2.22k | ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { | 840 | 2.22k | if (EF.getHeader()->e_type != ELF::ET_REL) | 841 | 68 | return section_end(); | 842 | 2.15k | | 843 | 2.15k | const Elf_Shdr *EShdr = getSection(Sec); | 844 | 2.15k | uintX_t Type = EShdr->sh_type; | 845 | 2.15k | if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA1.87k ) | 846 | 1.74k | return section_end(); | 847 | 408 | | 848 | 408 | auto R = EF.getSection(EShdr->sh_info); | 849 | 408 | if (!R) | 850 | 0 | report_fatal_error(errorToErrorCode(R.takeError()).message()); | 851 | 408 | return section_iterator(SectionRef(toDRI(*R), this)); | 852 | 408 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocatedSection(llvm::object::DataRefImpl) const Line | Count | Source | 839 | 1.47k | ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { | 840 | 1.47k | if (EF.getHeader()->e_type != ELF::ET_REL) | 841 | 0 | return section_end(); | 842 | 1.47k | | 843 | 1.47k | const Elf_Shdr *EShdr = getSection(Sec); | 844 | 1.47k | uintX_t Type = EShdr->sh_type; | 845 | 1.47k | if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA1.34k ) | 846 | 1.24k | return section_end(); | 847 | 239 | | 848 | 239 | auto R = EF.getSection(EShdr->sh_info); | 849 | 239 | if (!R) | 850 | 0 | report_fatal_error(errorToErrorCode(R.takeError()).message()); | 851 | 239 | return section_iterator(SectionRef(toDRI(*R), this)); | 852 | 239 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocatedSection(llvm::object::DataRefImpl) const Line | Count | Source | 839 | 12.3k | ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { | 840 | 12.3k | if (EF.getHeader()->e_type != ELF::ET_REL) | 841 | 3.23k | return section_end(); | 842 | 9.15k | | 843 | 9.15k | const Elf_Shdr *EShdr = getSection(Sec); | 844 | 9.15k | uintX_t Type = EShdr->sh_type; | 845 | 9.15k | if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA9.12k ) | 846 | 7.13k | return section_end(); | 847 | 2.01k | | 848 | 2.01k | auto R = EF.getSection(EShdr->sh_info); | 849 | 2.01k | if (!R) | 850 | 1 | report_fatal_error(errorToErrorCode(R.takeError()).message()); | 851 | 2.01k | return section_iterator(SectionRef(toDRI(*R), this)); | 852 | 2.01k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocatedSection(llvm::object::DataRefImpl) const Line | Count | Source | 839 | 1.44k | ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { | 840 | 1.44k | if (EF.getHeader()->e_type != ELF::ET_REL) | 841 | 62 | return section_end(); | 842 | 1.38k | | 843 | 1.38k | const Elf_Shdr *EShdr = getSection(Sec); | 844 | 1.38k | uintX_t Type = EShdr->sh_type; | 845 | 1.38k | if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA1.37k ) | 846 | 1.13k | return section_end(); | 847 | 252 | | 848 | 252 | auto R = EF.getSection(EShdr->sh_info); | 849 | 252 | if (!R) | 850 | 0 | report_fatal_error(errorToErrorCode(R.takeError()).message()); | 851 | 252 | return section_iterator(SectionRef(toDRI(*R), this)); | 852 | 252 | } |
|
853 | | |
854 | | // Relocations |
855 | | template <class ELFT> |
856 | 8.44k | void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { |
857 | 8.44k | ++Rel.d.b; |
858 | 8.44k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::moveRelocationNext(llvm::object::DataRefImpl&) const Line | Count | Source | 856 | 993 | void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { | 857 | 993 | ++Rel.d.b; | 858 | 993 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::moveRelocationNext(llvm::object::DataRefImpl&) const Line | Count | Source | 856 | 305 | void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { | 857 | 305 | ++Rel.d.b; | 858 | 305 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::moveRelocationNext(llvm::object::DataRefImpl&) const Line | Count | Source | 856 | 6.85k | void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { | 857 | 6.85k | ++Rel.d.b; | 858 | 6.85k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::moveRelocationNext(llvm::object::DataRefImpl&) const Line | Count | Source | 856 | 295 | void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { | 857 | 295 | ++Rel.d.b; | 858 | 295 | } |
|
859 | | |
860 | | template <class ELFT> |
861 | | symbol_iterator |
862 | 8.07k | ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { |
863 | 8.07k | uint32_t symbolIdx; |
864 | 8.07k | const Elf_Shdr *sec = getRelSection(Rel); |
865 | 8.07k | if (sec->sh_type == ELF::SHT_REL) |
866 | 1.06k | symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); |
867 | 7.01k | else |
868 | 7.01k | symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); |
869 | 8.07k | if (!symbolIdx) |
870 | 91 | return symbol_end(); |
871 | 7.98k | |
872 | 7.98k | // FIXME: error check symbolIdx |
873 | 7.98k | DataRefImpl SymbolData; |
874 | 7.98k | SymbolData.d.a = sec->sh_link; |
875 | 7.98k | SymbolData.d.b = symbolIdx; |
876 | 7.98k | return symbol_iterator(SymbolRef(SymbolData, this)); |
877 | 7.98k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocationSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 862 | 1.04k | ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { | 863 | 1.04k | uint32_t symbolIdx; | 864 | 1.04k | const Elf_Shdr *sec = getRelSection(Rel); | 865 | 1.04k | if (sec->sh_type == ELF::SHT_REL) | 866 | 677 | symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); | 867 | 366 | else | 868 | 366 | symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); | 869 | 1.04k | if (!symbolIdx) | 870 | 22 | return symbol_end(); | 871 | 1.02k | | 872 | 1.02k | // FIXME: error check symbolIdx | 873 | 1.02k | DataRefImpl SymbolData; | 874 | 1.02k | SymbolData.d.a = sec->sh_link; | 875 | 1.02k | SymbolData.d.b = symbolIdx; | 876 | 1.02k | return symbol_iterator(SymbolRef(SymbolData, this)); | 877 | 1.02k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocationSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 862 | 438 | ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { | 863 | 438 | uint32_t symbolIdx; | 864 | 438 | const Elf_Shdr *sec = getRelSection(Rel); | 865 | 438 | if (sec->sh_type == ELF::SHT_REL) | 866 | 266 | symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); | 867 | 172 | else | 868 | 172 | symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); | 869 | 438 | if (!symbolIdx) | 870 | 0 | return symbol_end(); | 871 | 438 | | 872 | 438 | // FIXME: error check symbolIdx | 873 | 438 | DataRefImpl SymbolData; | 874 | 438 | SymbolData.d.a = sec->sh_link; | 875 | 438 | SymbolData.d.b = symbolIdx; | 876 | 438 | return symbol_iterator(SymbolRef(SymbolData, this)); | 877 | 438 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocationSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 862 | 6.24k | ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { | 863 | 6.24k | uint32_t symbolIdx; | 864 | 6.24k | const Elf_Shdr *sec = getRelSection(Rel); | 865 | 6.24k | if (sec->sh_type == ELF::SHT_REL) | 866 | 74 | symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); | 867 | 6.17k | else | 868 | 6.17k | symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); | 869 | 6.24k | if (!symbolIdx) | 870 | 69 | return symbol_end(); | 871 | 6.18k | | 872 | 6.18k | // FIXME: error check symbolIdx | 873 | 6.18k | DataRefImpl SymbolData; | 874 | 6.18k | SymbolData.d.a = sec->sh_link; | 875 | 6.18k | SymbolData.d.b = symbolIdx; | 876 | 6.18k | return symbol_iterator(SymbolRef(SymbolData, this)); | 877 | 6.18k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocationSymbol(llvm::object::DataRefImpl) const Line | Count | Source | 862 | 343 | ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { | 863 | 343 | uint32_t symbolIdx; | 864 | 343 | const Elf_Shdr *sec = getRelSection(Rel); | 865 | 343 | if (sec->sh_type == ELF::SHT_REL) | 866 | 45 | symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); | 867 | 298 | else | 868 | 298 | symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); | 869 | 343 | if (!symbolIdx) | 870 | 0 | return symbol_end(); | 871 | 343 | | 872 | 343 | // FIXME: error check symbolIdx | 873 | 343 | DataRefImpl SymbolData; | 874 | 343 | SymbolData.d.a = sec->sh_link; | 875 | 343 | SymbolData.d.b = symbolIdx; | 876 | 343 | return symbol_iterator(SymbolRef(SymbolData, this)); | 877 | 343 | } |
|
878 | | |
879 | | template <class ELFT> |
880 | 9.55k | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { |
881 | 9.55k | const Elf_Shdr *sec = getRelSection(Rel); |
882 | 9.55k | if (sec->sh_type == ELF::SHT_REL) |
883 | 1.46k | return getRel(Rel)->r_offset; |
884 | 8.09k | |
885 | 8.09k | return getRela(Rel)->r_offset; |
886 | 8.09k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocationOffset(llvm::object::DataRefImpl) const Line | Count | Source | 880 | 1.72k | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { | 881 | 1.72k | const Elf_Shdr *sec = getRelSection(Rel); | 882 | 1.72k | if (sec->sh_type == ELF::SHT_REL) | 883 | 936 | return getRel(Rel)->r_offset; | 884 | 787 | | 885 | 787 | return getRela(Rel)->r_offset; | 886 | 787 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocationOffset(llvm::object::DataRefImpl) const Line | Count | Source | 880 | 691 | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { | 881 | 691 | const Elf_Shdr *sec = getRelSection(Rel); | 882 | 691 | if (sec->sh_type == ELF::SHT_REL) | 883 | 378 | return getRel(Rel)->r_offset; | 884 | 313 | | 885 | 313 | return getRela(Rel)->r_offset; | 886 | 313 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocationOffset(llvm::object::DataRefImpl) const Line | Count | Source | 880 | 6.65k | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { | 881 | 6.65k | const Elf_Shdr *sec = getRelSection(Rel); | 882 | 6.65k | if (sec->sh_type == ELF::SHT_REL) | 883 | 108 | return getRel(Rel)->r_offset; | 884 | 6.55k | | 885 | 6.55k | return getRela(Rel)->r_offset; | 886 | 6.55k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocationOffset(llvm::object::DataRefImpl) const Line | Count | Source | 880 | 486 | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { | 881 | 486 | const Elf_Shdr *sec = getRelSection(Rel); | 882 | 486 | if (sec->sh_type == ELF::SHT_REL) | 883 | 45 | return getRel(Rel)->r_offset; | 884 | 441 | | 885 | 441 | return getRela(Rel)->r_offset; | 886 | 441 | } |
|
887 | | |
888 | | template <class ELFT> |
889 | 16.6k | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { |
890 | 16.6k | const Elf_Shdr *sec = getRelSection(Rel); |
891 | 16.6k | if (sec->sh_type == ELF::SHT_REL) |
892 | 1.71k | return getRel(Rel)->getType(EF.isMips64EL()); |
893 | 14.8k | else |
894 | 14.8k | return getRela(Rel)->getType(EF.isMips64EL()); |
895 | 16.6k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocationType(llvm::object::DataRefImpl) const Line | Count | Source | 889 | 1.71k | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { | 890 | 1.71k | const Elf_Shdr *sec = getRelSection(Rel); | 891 | 1.71k | if (sec->sh_type == ELF::SHT_REL) | 892 | 1.20k | return getRel(Rel)->getType(EF.isMips64EL()); | 893 | 509 | else | 894 | 509 | return getRela(Rel)->getType(EF.isMips64EL()); | 895 | 1.71k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocationType(llvm::object::DataRefImpl) const Line | Count | Source | 889 | 497 | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { | 890 | 497 | const Elf_Shdr *sec = getRelSection(Rel); | 891 | 497 | if (sec->sh_type == ELF::SHT_REL) | 892 | 392 | return getRel(Rel)->getType(EF.isMips64EL()); | 893 | 105 | else | 894 | 105 | return getRela(Rel)->getType(EF.isMips64EL()); | 895 | 497 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocationType(llvm::object::DataRefImpl) const Line | Count | Source | 889 | 13.9k | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { | 890 | 13.9k | const Elf_Shdr *sec = getRelSection(Rel); | 891 | 13.9k | if (sec->sh_type == ELF::SHT_REL) | 892 | 74 | return getRel(Rel)->getType(EF.isMips64EL()); | 893 | 13.9k | else | 894 | 13.9k | return getRela(Rel)->getType(EF.isMips64EL()); | 895 | 13.9k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocationType(llvm::object::DataRefImpl) const Line | Count | Source | 889 | 399 | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { | 890 | 399 | const Elf_Shdr *sec = getRelSection(Rel); | 891 | 399 | if (sec->sh_type == ELF::SHT_REL) | 892 | 48 | return getRel(Rel)->getType(EF.isMips64EL()); | 893 | 351 | else | 894 | 351 | return getRela(Rel)->getType(EF.isMips64EL()); | 895 | 399 | } |
|
896 | | |
897 | | template <class ELFT> |
898 | | StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const { |
899 | | return getELFRelocationTypeName(EF.getHeader()->e_machine, Type); |
900 | | } |
901 | | |
902 | | template <class ELFT> |
903 | | void ELFObjectFile<ELFT>::getRelocationTypeName( |
904 | 1.02k | DataRefImpl Rel, SmallVectorImpl<char> &Result) const { |
905 | 1.02k | uint32_t type = getRelocationType(Rel); |
906 | 1.02k | EF.getRelocationTypeName(type, Result); |
907 | 1.02k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocationTypeName(llvm::object::DataRefImpl, llvm::SmallVectorImpl<char>&) const Line | Count | Source | 904 | 307 | DataRefImpl Rel, SmallVectorImpl<char> &Result) const { | 905 | 307 | uint32_t type = getRelocationType(Rel); | 906 | 307 | EF.getRelocationTypeName(type, Result); | 907 | 307 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocationTypeName(llvm::object::DataRefImpl, llvm::SmallVectorImpl<char>&) const Line | Count | Source | 904 | 87 | DataRefImpl Rel, SmallVectorImpl<char> &Result) const { | 905 | 87 | uint32_t type = getRelocationType(Rel); | 906 | 87 | EF.getRelocationTypeName(type, Result); | 907 | 87 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocationTypeName(llvm::object::DataRefImpl, llvm::SmallVectorImpl<char>&) const Line | Count | Source | 904 | 561 | DataRefImpl Rel, SmallVectorImpl<char> &Result) const { | 905 | 561 | uint32_t type = getRelocationType(Rel); | 906 | 561 | EF.getRelocationTypeName(type, Result); | 907 | 561 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocationTypeName(llvm::object::DataRefImpl, llvm::SmallVectorImpl<char>&) const Line | Count | Source | 904 | 74 | DataRefImpl Rel, SmallVectorImpl<char> &Result) const { | 905 | 74 | uint32_t type = getRelocationType(Rel); | 906 | 74 | EF.getRelocationTypeName(type, Result); | 907 | 74 | } |
|
908 | | |
909 | | template <class ELFT> |
910 | | Expected<int64_t> |
911 | 7.91k | ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { |
912 | 7.91k | if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) |
913 | 41 | return createError("Section is not SHT_RELA"); |
914 | 7.87k | return (int64_t)getRela(Rel)->r_addend; |
915 | 7.87k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocationAddend(llvm::object::DataRefImpl) const Line | Count | Source | 911 | 217 | ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { | 912 | 217 | if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) | 913 | 21 | return createError("Section is not SHT_RELA"); | 914 | 196 | return (int64_t)getRela(Rel)->r_addend; | 915 | 196 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocationAddend(llvm::object::DataRefImpl) const Line | Count | Source | 911 | 51 | ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { | 912 | 51 | if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) | 913 | 19 | return createError("Section is not SHT_RELA"); | 914 | 32 | return (int64_t)getRela(Rel)->r_addend; | 915 | 32 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocationAddend(llvm::object::DataRefImpl) const Line | Count | Source | 911 | 7.46k | ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { | 912 | 7.46k | if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) | 913 | 1 | return createError("Section is not SHT_RELA"); | 914 | 7.46k | return (int64_t)getRela(Rel)->r_addend; | 915 | 7.46k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocationAddend(llvm::object::DataRefImpl) const Line | Count | Source | 911 | 183 | ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { | 912 | 183 | if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) | 913 | 0 | return createError("Section is not SHT_RELA"); | 914 | 183 | return (int64_t)getRela(Rel)->r_addend; | 915 | 183 | } |
|
916 | | |
917 | | template <class ELFT> |
918 | | const typename ELFObjectFile<ELFT>::Elf_Rel * |
919 | 4.24k | ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { |
920 | 4.24k | assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); |
921 | 4.24k | auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); |
922 | 4.24k | if (!Ret) |
923 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); |
924 | 4.24k | return *Ret; |
925 | 4.24k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRel(llvm::object::DataRefImpl) const Line | Count | Source | 919 | 2.81k | ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { | 920 | 2.81k | assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); | 921 | 2.81k | auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); | 922 | 2.81k | if (!Ret) | 923 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 924 | 2.81k | return *Ret; | 925 | 2.81k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRel(llvm::object::DataRefImpl) const Line | Count | Source | 919 | 1.03k | ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { | 920 | 1.03k | assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); | 921 | 1.03k | auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); | 922 | 1.03k | if (!Ret) | 923 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 924 | 1.03k | return *Ret; | 925 | 1.03k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRel(llvm::object::DataRefImpl) const Line | Count | Source | 919 | 256 | ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { | 920 | 256 | assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); | 921 | 256 | auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); | 922 | 256 | if (!Ret) | 923 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 924 | 256 | return *Ret; | 925 | 256 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRel(llvm::object::DataRefImpl) const Line | Count | Source | 919 | 138 | ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { | 920 | 138 | assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); | 921 | 138 | auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); | 922 | 138 | if (!Ret) | 923 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 924 | 138 | return *Ret; | 925 | 138 | } |
|
926 | | |
927 | | template <class ELFT> |
928 | | const typename ELFObjectFile<ELFT>::Elf_Rela * |
929 | 38.5k | ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { |
930 | 38.5k | assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); |
931 | 38.5k | auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); |
932 | 38.5k | if (!Ret) |
933 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); |
934 | 38.5k | return *Ret; |
935 | 38.5k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRela(llvm::object::DataRefImpl) const Line | Count | Source | 929 | 1.99k | ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { | 930 | 1.99k | assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); | 931 | 1.99k | auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); | 932 | 1.99k | if (!Ret) | 933 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 934 | 1.99k | return *Ret; | 935 | 1.99k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRela(llvm::object::DataRefImpl) const Line | Count | Source | 929 | 668 | ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { | 930 | 668 | assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); | 931 | 668 | auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); | 932 | 668 | if (!Ret) | 933 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 934 | 668 | return *Ret; | 935 | 668 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRela(llvm::object::DataRefImpl) const Line | Count | Source | 929 | 34.6k | ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { | 930 | 34.6k | assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); | 931 | 34.6k | auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); | 932 | 34.6k | if (!Ret) | 933 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 934 | 34.6k | return *Ret; | 935 | 34.6k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRela(llvm::object::DataRefImpl) const Line | Count | Source | 929 | 1.32k | ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { | 930 | 1.32k | assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); | 931 | 1.32k | auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); | 932 | 1.32k | if (!Ret) | 933 | 0 | report_fatal_error(errorToErrorCode(Ret.takeError()).message()); | 934 | 1.32k | return *Ret; | 935 | 1.32k | } |
|
936 | | |
937 | | template <class ELFT> |
938 | | Expected<ELFObjectFile<ELFT>> |
939 | 8.06k | ELFObjectFile<ELFT>::create(MemoryBufferRef Object) { |
940 | 8.06k | auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); |
941 | 8.06k | if (Error E = EFOrErr.takeError()) |
942 | 1 | return std::move(E); |
943 | 8.06k | auto EF = std::move(*EFOrErr); |
944 | 8.06k | |
945 | 8.06k | auto SectionsOrErr = EF.sections(); |
946 | 8.06k | if (!SectionsOrErr) |
947 | 5 | return SectionsOrErr.takeError(); |
948 | 8.06k | |
949 | 8.06k | const Elf_Shdr *DotDynSymSec = nullptr; |
950 | 8.06k | const Elf_Shdr *DotSymtabSec = nullptr; |
951 | 8.06k | ArrayRef<Elf_Word> ShndxTable; |
952 | 1.70M | for (const Elf_Shdr &Sec : *SectionsOrErr) { |
953 | 1.70M | switch (Sec.sh_type) { |
954 | 1.70M | case ELF::SHT_DYNSYM: { |
955 | 1.38k | if (!DotDynSymSec) |
956 | 1.36k | DotDynSymSec = &Sec; |
957 | 1.38k | break; |
958 | 1.70M | } |
959 | 1.70M | case ELF::SHT_SYMTAB: { |
960 | 7.89k | if (!DotSymtabSec) |
961 | 7.89k | DotSymtabSec = &Sec; |
962 | 7.89k | break; |
963 | 1.70M | } |
964 | 1.70M | case ELF::SHT_SYMTAB_SHNDX: { |
965 | 26 | auto TableOrErr = EF.getSHNDXTable(Sec); |
966 | 26 | if (!TableOrErr) |
967 | 1 | return TableOrErr.takeError(); |
968 | 25 | ShndxTable = *TableOrErr; |
969 | 25 | break; |
970 | 25 | } |
971 | 1.70M | } |
972 | 1.70M | } |
973 | 8.06k | return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, |
974 | 8.06k | ShndxTable); |
975 | 8.06k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::create(llvm::MemoryBufferRef) Line | Count | Source | 939 | 1.47k | ELFObjectFile<ELFT>::create(MemoryBufferRef Object) { | 940 | 1.47k | auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); | 941 | 1.47k | if (Error E = EFOrErr.takeError()) | 942 | 0 | return std::move(E); | 943 | 1.47k | auto EF = std::move(*EFOrErr); | 944 | 1.47k | | 945 | 1.47k | auto SectionsOrErr = EF.sections(); | 946 | 1.47k | if (!SectionsOrErr) | 947 | 0 | return SectionsOrErr.takeError(); | 948 | 1.47k | | 949 | 1.47k | const Elf_Shdr *DotDynSymSec = nullptr; | 950 | 1.47k | const Elf_Shdr *DotSymtabSec = nullptr; | 951 | 1.47k | ArrayRef<Elf_Word> ShndxTable; | 952 | 12.5k | for (const Elf_Shdr &Sec : *SectionsOrErr) { | 953 | 12.5k | switch (Sec.sh_type) { | 954 | 12.5k | case ELF::SHT_DYNSYM: { | 955 | 243 | if (!DotDynSymSec) | 956 | 239 | DotDynSymSec = &Sec; | 957 | 243 | break; | 958 | 12.5k | } | 959 | 12.5k | case ELF::SHT_SYMTAB: { | 960 | 1.45k | if (!DotSymtabSec) | 961 | 1.45k | DotSymtabSec = &Sec; | 962 | 1.45k | break; | 963 | 12.5k | } | 964 | 12.5k | case ELF::SHT_SYMTAB_SHNDX: { | 965 | 2 | auto TableOrErr = EF.getSHNDXTable(Sec); | 966 | 2 | if (!TableOrErr) | 967 | 0 | return TableOrErr.takeError(); | 968 | 2 | ShndxTable = *TableOrErr; | 969 | 2 | break; | 970 | 2 | } | 971 | 12.5k | } | 972 | 12.5k | } | 973 | 1.47k | return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, | 974 | 1.47k | ShndxTable); | 975 | 1.47k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::create(llvm::MemoryBufferRef) Line | Count | Source | 939 | 367 | ELFObjectFile<ELFT>::create(MemoryBufferRef Object) { | 940 | 367 | auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); | 941 | 367 | if (Error E = EFOrErr.takeError()) | 942 | 0 | return std::move(E); | 943 | 367 | auto EF = std::move(*EFOrErr); | 944 | 367 | | 945 | 367 | auto SectionsOrErr = EF.sections(); | 946 | 367 | if (!SectionsOrErr) | 947 | 0 | return SectionsOrErr.takeError(); | 948 | 367 | | 949 | 367 | const Elf_Shdr *DotDynSymSec = nullptr; | 950 | 367 | const Elf_Shdr *DotSymtabSec = nullptr; | 951 | 367 | ArrayRef<Elf_Word> ShndxTable; | 952 | 4.18k | for (const Elf_Shdr &Sec : *SectionsOrErr) { | 953 | 4.18k | switch (Sec.sh_type) { | 954 | 4.18k | case ELF::SHT_DYNSYM: { | 955 | 98 | if (!DotDynSymSec) | 956 | 98 | DotDynSymSec = &Sec; | 957 | 98 | break; | 958 | 4.18k | } | 959 | 4.18k | case ELF::SHT_SYMTAB: { | 960 | 361 | if (!DotSymtabSec) | 961 | 361 | DotSymtabSec = &Sec; | 962 | 361 | break; | 963 | 4.18k | } | 964 | 4.18k | case ELF::SHT_SYMTAB_SHNDX: { | 965 | 0 | auto TableOrErr = EF.getSHNDXTable(Sec); | 966 | 0 | if (!TableOrErr) | 967 | 0 | return TableOrErr.takeError(); | 968 | 0 | ShndxTable = *TableOrErr; | 969 | 0 | break; | 970 | 0 | } | 971 | 4.18k | } | 972 | 4.18k | } | 973 | 367 | return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, | 974 | 367 | ShndxTable); | 975 | 367 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::create(llvm::MemoryBufferRef) Line | Count | Source | 939 | 5.97k | ELFObjectFile<ELFT>::create(MemoryBufferRef Object) { | 940 | 5.97k | auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); | 941 | 5.97k | if (Error E = EFOrErr.takeError()) | 942 | 1 | return std::move(E); | 943 | 5.97k | auto EF = std::move(*EFOrErr); | 944 | 5.97k | | 945 | 5.97k | auto SectionsOrErr = EF.sections(); | 946 | 5.97k | if (!SectionsOrErr) | 947 | 5 | return SectionsOrErr.takeError(); | 948 | 5.97k | | 949 | 5.97k | const Elf_Shdr *DotDynSymSec = nullptr; | 950 | 5.97k | const Elf_Shdr *DotSymtabSec = nullptr; | 951 | 5.97k | ArrayRef<Elf_Word> ShndxTable; | 952 | 1.68M | for (const Elf_Shdr &Sec : *SectionsOrErr) { | 953 | 1.68M | switch (Sec.sh_type) { | 954 | 1.68M | case ELF::SHT_DYNSYM: { | 955 | 995 | if (!DotDynSymSec) | 956 | 976 | DotDynSymSec = &Sec; | 957 | 995 | break; | 958 | 1.68M | } | 959 | 1.68M | case ELF::SHT_SYMTAB: { | 960 | 5.83k | if (!DotSymtabSec) | 961 | 5.83k | DotSymtabSec = &Sec; | 962 | 5.83k | break; | 963 | 1.68M | } | 964 | 1.68M | case ELF::SHT_SYMTAB_SHNDX: { | 965 | 24 | auto TableOrErr = EF.getSHNDXTable(Sec); | 966 | 24 | if (!TableOrErr) | 967 | 1 | return TableOrErr.takeError(); | 968 | 23 | ShndxTable = *TableOrErr; | 969 | 23 | break; | 970 | 23 | } | 971 | 1.68M | } | 972 | 1.68M | } | 973 | 5.97k | return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, | 974 | 5.97k | ShndxTable); | 975 | 5.97k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::create(llvm::MemoryBufferRef) Line | Count | Source | 939 | 253 | ELFObjectFile<ELFT>::create(MemoryBufferRef Object) { | 940 | 253 | auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); | 941 | 253 | if (Error E = EFOrErr.takeError()) | 942 | 0 | return std::move(E); | 943 | 253 | auto EF = std::move(*EFOrErr); | 944 | 253 | | 945 | 253 | auto SectionsOrErr = EF.sections(); | 946 | 253 | if (!SectionsOrErr) | 947 | 0 | return SectionsOrErr.takeError(); | 948 | 253 | | 949 | 253 | const Elf_Shdr *DotDynSymSec = nullptr; | 950 | 253 | const Elf_Shdr *DotSymtabSec = nullptr; | 951 | 253 | ArrayRef<Elf_Word> ShndxTable; | 952 | 2.71k | for (const Elf_Shdr &Sec : *SectionsOrErr) { | 953 | 2.71k | switch (Sec.sh_type) { | 954 | 2.71k | case ELF::SHT_DYNSYM: { | 955 | 50 | if (!DotDynSymSec) | 956 | 50 | DotDynSymSec = &Sec; | 957 | 50 | break; | 958 | 2.71k | } | 959 | 2.71k | case ELF::SHT_SYMTAB: { | 960 | 249 | if (!DotSymtabSec) | 961 | 249 | DotSymtabSec = &Sec; | 962 | 249 | break; | 963 | 2.71k | } | 964 | 2.71k | case ELF::SHT_SYMTAB_SHNDX: { | 965 | 0 | auto TableOrErr = EF.getSHNDXTable(Sec); | 966 | 0 | if (!TableOrErr) | 967 | 0 | return TableOrErr.takeError(); | 968 | 0 | ShndxTable = *TableOrErr; | 969 | 0 | break; | 970 | 0 | } | 971 | 2.71k | } | 972 | 2.71k | } | 973 | 253 | return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, | 974 | 253 | ShndxTable); | 975 | 253 | } |
|
976 | | |
977 | | template <class ELFT> |
978 | | ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF, |
979 | | const Elf_Shdr *DotDynSymSec, |
980 | | const Elf_Shdr *DotSymtabSec, |
981 | | ArrayRef<Elf_Word> ShndxTable) |
982 | | : ELFObjectFileBase( |
983 | | getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits), |
984 | | Object), |
985 | | EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec), |
986 | 24.1k | ShndxTable(ShndxTable) {} llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::ELFObjectFile(llvm::MemoryBufferRef, llvm::object::ELFFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false> > const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::support::endianness)1, 1ul> >) Line | Count | Source | 986 | 4.41k | ShndxTable(ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::ELFObjectFile(llvm::MemoryBufferRef, llvm::object::ELFFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false> > const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::support::endianness)0, 1ul> >) Line | Count | Source | 986 | 1.10k | ShndxTable(ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::ELFObjectFile(llvm::MemoryBufferRef, llvm::object::ELFFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true> > const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::support::endianness)1, 1ul> >) Line | Count | Source | 986 | 17.9k | ShndxTable(ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::ELFObjectFile(llvm::MemoryBufferRef, llvm::object::ELFFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true> > const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::support::endianness)0, 1ul> >) Line | Count | Source | 986 | 759 | ShndxTable(ShndxTable) {} |
|
987 | | |
988 | | template <class ELFT> |
989 | | ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other) |
990 | | : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec, |
991 | 16.1k | Other.DotSymtabSec, Other.ShndxTable) {} llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::ELFObjectFile(llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >&&) Line | Count | Source | 991 | 2.94k | Other.DotSymtabSec, Other.ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::ELFObjectFile(llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >&&) Line | Count | Source | 991 | 734 | Other.DotSymtabSec, Other.ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::ELFObjectFile(llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >&&) Line | Count | Source | 991 | 11.9k | Other.DotSymtabSec, Other.ShndxTable) {} |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::ELFObjectFile(llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >&&) Line | Count | Source | 991 | 506 | Other.DotSymtabSec, Other.ShndxTable) {} |
|
992 | | |
993 | | template <class ELFT> |
994 | 3.33k | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { |
995 | 3.33k | DataRefImpl Sym = |
996 | 3.33k | toDRI(DotSymtabSec, |
997 | 3.33k | DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym)3.30k ? 13.30k : 034 ); |
998 | 3.33k | return basic_symbol_iterator(SymbolRef(Sym, this)); |
999 | 3.33k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::symbol_begin() const Line | Count | Source | 994 | 593 | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { | 995 | 593 | DataRefImpl Sym = | 996 | 593 | toDRI(DotSymtabSec, | 997 | 593 | DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym)591 ? 1591 : 02 ); | 998 | 593 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 999 | 593 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::symbol_begin() const Line | Count | Source | 994 | 139 | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { | 995 | 139 | DataRefImpl Sym = | 996 | 139 | toDRI(DotSymtabSec, | 997 | 139 | DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym) ? 1 : 00 ); | 998 | 139 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 999 | 139 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::symbol_begin() const Line | Count | Source | 994 | 2.51k | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { | 995 | 2.51k | DataRefImpl Sym = | 996 | 2.51k | toDRI(DotSymtabSec, | 997 | 2.51k | DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym)2.48k ? 12.48k : 032 ); | 998 | 2.51k | return basic_symbol_iterator(SymbolRef(Sym, this)); | 999 | 2.51k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::symbol_begin() const Line | Count | Source | 994 | 89 | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { | 995 | 89 | DataRefImpl Sym = | 996 | 89 | toDRI(DotSymtabSec, | 997 | 89 | DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym) ? 1 : 00 ); | 998 | 89 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 999 | 89 | } |
|
1000 | | |
1001 | | template <class ELFT> |
1002 | 10.4k | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { |
1003 | 10.4k | const Elf_Shdr *SymTab = DotSymtabSec; |
1004 | 10.4k | if (!SymTab) |
1005 | 17 | return symbol_begin(); |
1006 | 10.4k | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); |
1007 | 10.4k | return basic_symbol_iterator(SymbolRef(Sym, this)); |
1008 | 10.4k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::symbol_end() const Line | Count | Source | 1002 | 1.33k | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { | 1003 | 1.33k | const Elf_Shdr *SymTab = DotSymtabSec; | 1004 | 1.33k | if (!SymTab) | 1005 | 1 | return symbol_begin(); | 1006 | 1.33k | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1007 | 1.33k | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1008 | 1.33k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::symbol_end() const Line | Count | Source | 1002 | 437 | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { | 1003 | 437 | const Elf_Shdr *SymTab = DotSymtabSec; | 1004 | 437 | if (!SymTab) | 1005 | 0 | return symbol_begin(); | 1006 | 437 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1007 | 437 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1008 | 437 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::symbol_end() const Line | Count | Source | 1002 | 8.33k | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { | 1003 | 8.33k | const Elf_Shdr *SymTab = DotSymtabSec; | 1004 | 8.33k | if (!SymTab) | 1005 | 16 | return symbol_begin(); | 1006 | 8.31k | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1007 | 8.31k | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1008 | 8.31k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::symbol_end() const Line | Count | Source | 1002 | 354 | basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { | 1003 | 354 | const Elf_Shdr *SymTab = DotSymtabSec; | 1004 | 354 | if (!SymTab) | 1005 | 0 | return symbol_begin(); | 1006 | 354 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1007 | 354 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1008 | 354 | } |
|
1009 | | |
1010 | | template <class ELFT> |
1011 | 528 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { |
1012 | 528 | DataRefImpl Sym = toDRI(DotDynSymSec, 0); |
1013 | 528 | return symbol_iterator(SymbolRef(Sym, this)); |
1014 | 528 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::dynamic_symbol_begin() const Line | Count | Source | 1011 | 318 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { | 1012 | 318 | DataRefImpl Sym = toDRI(DotDynSymSec, 0); | 1013 | 318 | return symbol_iterator(SymbolRef(Sym, this)); | 1014 | 318 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::dynamic_symbol_begin() const Line | Count | Source | 1011 | 14 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { | 1012 | 14 | DataRefImpl Sym = toDRI(DotDynSymSec, 0); | 1013 | 14 | return symbol_iterator(SymbolRef(Sym, this)); | 1014 | 14 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::dynamic_symbol_begin() const Line | Count | Source | 1011 | 194 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { | 1012 | 194 | DataRefImpl Sym = toDRI(DotDynSymSec, 0); | 1013 | 194 | return symbol_iterator(SymbolRef(Sym, this)); | 1014 | 194 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::dynamic_symbol_begin() const Line | Count | Source | 1011 | 2 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { | 1012 | 2 | DataRefImpl Sym = toDRI(DotDynSymSec, 0); | 1013 | 2 | return symbol_iterator(SymbolRef(Sym, this)); | 1014 | 2 | } |
|
1015 | | |
1016 | | template <class ELFT> |
1017 | 268 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { |
1018 | 268 | const Elf_Shdr *SymTab = DotDynSymSec; |
1019 | 268 | if (!SymTab) |
1020 | 260 | return dynamic_symbol_begin(); |
1021 | 8 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); |
1022 | 8 | return basic_symbol_iterator(SymbolRef(Sym, this)); |
1023 | 8 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::dynamic_symbol_end() const Line | Count | Source | 1017 | 160 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { | 1018 | 160 | const Elf_Shdr *SymTab = DotDynSymSec; | 1019 | 160 | if (!SymTab) | 1020 | 158 | return dynamic_symbol_begin(); | 1021 | 2 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1022 | 2 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1023 | 2 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::dynamic_symbol_end() const Line | Count | Source | 1017 | 7 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { | 1018 | 7 | const Elf_Shdr *SymTab = DotDynSymSec; | 1019 | 7 | if (!SymTab) | 1020 | 7 | return dynamic_symbol_begin(); | 1021 | 0 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1022 | 0 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1023 | 0 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::dynamic_symbol_end() const Line | Count | Source | 1017 | 100 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { | 1018 | 100 | const Elf_Shdr *SymTab = DotDynSymSec; | 1019 | 100 | if (!SymTab) | 1020 | 94 | return dynamic_symbol_begin(); | 1021 | 6 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1022 | 6 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1023 | 6 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::dynamic_symbol_end() const Line | Count | Source | 1017 | 1 | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { | 1018 | 1 | const Elf_Shdr *SymTab = DotDynSymSec; | 1019 | 1 | if (!SymTab) | 1020 | 1 | return dynamic_symbol_begin(); | 1021 | 0 | DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); | 1022 | 0 | return basic_symbol_iterator(SymbolRef(Sym, this)); | 1023 | 0 | } |
|
1024 | | |
1025 | | template <class ELFT> |
1026 | 9.46k | section_iterator ELFObjectFile<ELFT>::section_begin() const { |
1027 | 9.46k | auto SectionsOrErr = EF.sections(); |
1028 | 9.46k | if (!SectionsOrErr) |
1029 | 0 | return section_iterator(SectionRef()); |
1030 | 9.46k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); |
1031 | 9.46k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::section_begin() const Line | Count | Source | 1026 | 1.86k | section_iterator ELFObjectFile<ELFT>::section_begin() const { | 1027 | 1.86k | auto SectionsOrErr = EF.sections(); | 1028 | 1.86k | if (!SectionsOrErr) | 1029 | 0 | return section_iterator(SectionRef()); | 1030 | 1.86k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); | 1031 | 1.86k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::section_begin() const Line | Count | Source | 1026 | 446 | section_iterator ELFObjectFile<ELFT>::section_begin() const { | 1027 | 446 | auto SectionsOrErr = EF.sections(); | 1028 | 446 | if (!SectionsOrErr) | 1029 | 0 | return section_iterator(SectionRef()); | 1030 | 446 | return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); | 1031 | 446 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::section_begin() const Line | Count | Source | 1026 | 6.82k | section_iterator ELFObjectFile<ELFT>::section_begin() const { | 1027 | 6.82k | auto SectionsOrErr = EF.sections(); | 1028 | 6.82k | if (!SectionsOrErr) | 1029 | 0 | return section_iterator(SectionRef()); | 1030 | 6.82k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); | 1031 | 6.82k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::section_begin() const Line | Count | Source | 1026 | 329 | section_iterator ELFObjectFile<ELFT>::section_begin() const { | 1027 | 329 | auto SectionsOrErr = EF.sections(); | 1028 | 329 | if (!SectionsOrErr) | 1029 | 0 | return section_iterator(SectionRef()); | 1030 | 329 | return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); | 1031 | 329 | } |
|
1032 | | |
1033 | | template <class ELFT> |
1034 | 76.4k | section_iterator ELFObjectFile<ELFT>::section_end() const { |
1035 | 76.4k | auto SectionsOrErr = EF.sections(); |
1036 | 76.4k | if (!SectionsOrErr) |
1037 | 0 | return section_iterator(SectionRef()); |
1038 | 76.4k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); |
1039 | 76.4k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::section_end() const Line | Count | Source | 1034 | 15.2k | section_iterator ELFObjectFile<ELFT>::section_end() const { | 1035 | 15.2k | auto SectionsOrErr = EF.sections(); | 1036 | 15.2k | if (!SectionsOrErr) | 1037 | 0 | return section_iterator(SectionRef()); | 1038 | 15.2k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); | 1039 | 15.2k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::section_end() const Line | Count | Source | 1034 | 3.49k | section_iterator ELFObjectFile<ELFT>::section_end() const { | 1035 | 3.49k | auto SectionsOrErr = EF.sections(); | 1036 | 3.49k | if (!SectionsOrErr) | 1037 | 0 | return section_iterator(SectionRef()); | 1038 | 3.49k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); | 1039 | 3.49k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::section_end() const Line | Count | Source | 1034 | 54.9k | section_iterator ELFObjectFile<ELFT>::section_end() const { | 1035 | 54.9k | auto SectionsOrErr = EF.sections(); | 1036 | 54.9k | if (!SectionsOrErr) | 1037 | 0 | return section_iterator(SectionRef()); | 1038 | 54.9k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); | 1039 | 54.9k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::section_end() const Line | Count | Source | 1034 | 2.80k | section_iterator ELFObjectFile<ELFT>::section_end() const { | 1035 | 2.80k | auto SectionsOrErr = EF.sections(); | 1036 | 2.80k | if (!SectionsOrErr) | 1037 | 0 | return section_iterator(SectionRef()); | 1038 | 2.80k | return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); | 1039 | 2.80k | } |
|
1040 | | |
1041 | | template <class ELFT> |
1042 | 8.04k | uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { |
1043 | 8.04k | return ELFT::Is64Bits ? 86.07k : 41.96k ; |
1044 | 8.04k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getBytesInAddress() const Line | Count | Source | 1042 | 1.48k | uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { | 1043 | 1.48k | return ELFT::Is64Bits ? 80 : 4; | 1044 | 1.48k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getBytesInAddress() const Line | Count | Source | 1042 | 482 | uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { | 1043 | 482 | return ELFT::Is64Bits ? 80 : 4; | 1044 | 482 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getBytesInAddress() const Line | Count | Source | 1042 | 5.78k | uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { | 1043 | 5.78k | return ELFT::Is64Bits ? 8 : 40 ; | 1044 | 5.78k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getBytesInAddress() const Line | Count | Source | 1042 | 289 | uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { | 1043 | 289 | return ELFT::Is64Bits ? 8 : 40 ; | 1044 | 289 | } |
|
1045 | | |
1046 | | template <class ELFT> |
1047 | 5.79k | StringRef ELFObjectFile<ELFT>::getFileFormatName() const { |
1048 | 5.79k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; |
1049 | 5.79k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { |
1050 | 5.79k | case ELF::ELFCLASS32: |
1051 | 1.60k | switch (EF.getHeader()->e_machine) { |
1052 | 1.60k | case ELF::EM_386: |
1053 | 286 | return "ELF32-i386"; |
1054 | 1.60k | case ELF::EM_IAMCU: |
1055 | 6 | return "ELF32-iamcu"; |
1056 | 1.60k | case ELF::EM_X86_64: |
1057 | 10 | return "ELF32-x86-64"; |
1058 | 1.60k | case ELF::EM_ARM: |
1059 | 488 | return (IsLittleEndian ? "ELF32-arm-little"475 : "ELF32-arm-big"13 ); |
1060 | 1.60k | case ELF::EM_AVR: |
1061 | 0 | return "ELF32-avr"; |
1062 | 1.60k | case ELF::EM_HEXAGON: |
1063 | 120 | return "ELF32-hexagon"; |
1064 | 1.60k | case ELF::EM_LANAI: |
1065 | 4 | return "ELF32-lanai"; |
1066 | 1.60k | case ELF::EM_MIPS: |
1067 | 426 | return "ELF32-mips"; |
1068 | 1.60k | case ELF::EM_MSP430: |
1069 | 4 | return "ELF32-msp430"; |
1070 | 1.60k | case ELF::EM_PPC: |
1071 | 57 | return "ELF32-ppc"; |
1072 | 1.60k | case ELF::EM_RISCV: |
1073 | 151 | return "ELF32-riscv"; |
1074 | 1.60k | case ELF::EM_SPARC: |
1075 | 14 | case ELF::EM_SPARC32PLUS: |
1076 | 14 | return "ELF32-sparc"; |
1077 | 36 | case ELF::EM_AMDGPU: |
1078 | 36 | return "ELF32-amdgpu"; |
1079 | 14 | default: |
1080 | 4 | return "ELF32-unknown"; |
1081 | 0 | } |
1082 | 4.19k | case ELF::ELFCLASS64: |
1083 | 4.19k | switch (EF.getHeader()->e_machine) { |
1084 | 4.19k | case ELF::EM_386: |
1085 | 2 | return "ELF64-i386"; |
1086 | 4.19k | case ELF::EM_X86_64: |
1087 | 2.27k | return "ELF64-x86-64"; |
1088 | 4.19k | case ELF::EM_AARCH64: |
1089 | 1.27k | return (IsLittleEndian ? "ELF64-aarch64-little"1.26k : "ELF64-aarch64-big"8 ); |
1090 | 4.19k | case ELF::EM_PPC64: |
1091 | 173 | return "ELF64-ppc64"; |
1092 | 4.19k | case ELF::EM_RISCV: |
1093 | 111 | return "ELF64-riscv"; |
1094 | 4.19k | case ELF::EM_S390: |
1095 | 10 | return "ELF64-s390"; |
1096 | 4.19k | case ELF::EM_SPARCV9: |
1097 | 14 | return "ELF64-sparc"; |
1098 | 4.19k | case ELF::EM_MIPS: |
1099 | 162 | return "ELF64-mips"; |
1100 | 4.19k | case ELF::EM_AMDGPU: |
1101 | 144 | return "ELF64-amdgpu"; |
1102 | 4.19k | case ELF::EM_BPF: |
1103 | 22 | return "ELF64-BPF"; |
1104 | 4.19k | default: |
1105 | 6 | return "ELF64-unknown"; |
1106 | 0 | } |
1107 | 0 | default: |
1108 | 0 | // FIXME: Proper error handling. |
1109 | 0 | report_fatal_error("Invalid ELFCLASS!"); |
1110 | 5.79k | } |
1111 | 5.79k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getFileFormatName() const Line | Count | Source | 1047 | 1.26k | StringRef ELFObjectFile<ELFT>::getFileFormatName() const { | 1048 | 1.26k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1049 | 1.26k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1050 | 1.26k | case ELF::ELFCLASS32: | 1051 | 1.26k | switch (EF.getHeader()->e_machine) { | 1052 | 1.26k | case ELF::EM_386: | 1053 | 286 | return "ELF32-i386"; | 1054 | 1.26k | case ELF::EM_IAMCU: | 1055 | 6 | return "ELF32-iamcu"; | 1056 | 1.26k | case ELF::EM_X86_64: | 1057 | 9 | return "ELF32-x86-64"; | 1058 | 1.26k | case ELF::EM_ARM: | 1059 | 475 | return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big"0 ); | 1060 | 1.26k | case ELF::EM_AVR: | 1061 | 0 | return "ELF32-avr"; | 1062 | 1.26k | case ELF::EM_HEXAGON: | 1063 | 120 | return "ELF32-hexagon"; | 1064 | 1.26k | case ELF::EM_LANAI: | 1065 | 1 | return "ELF32-lanai"; | 1066 | 1.26k | case ELF::EM_MIPS: | 1067 | 167 | return "ELF32-mips"; | 1068 | 1.26k | case ELF::EM_MSP430: | 1069 | 4 | return "ELF32-msp430"; | 1070 | 1.26k | case ELF::EM_PPC: | 1071 | 2 | return "ELF32-ppc"; | 1072 | 1.26k | case ELF::EM_RISCV: | 1073 | 151 | return "ELF32-riscv"; | 1074 | 1.26k | case ELF::EM_SPARC: | 1075 | 4 | case ELF::EM_SPARC32PLUS: | 1076 | 4 | return "ELF32-sparc"; | 1077 | 36 | case ELF::EM_AMDGPU: | 1078 | 36 | return "ELF32-amdgpu"; | 1079 | 4 | default: | 1080 | 4 | return "ELF32-unknown"; | 1081 | 0 | } | 1082 | 0 | case ELF::ELFCLASS64: | 1083 | 0 | switch (EF.getHeader()->e_machine) { | 1084 | 0 | case ELF::EM_386: | 1085 | 0 | return "ELF64-i386"; | 1086 | 0 | case ELF::EM_X86_64: | 1087 | 0 | return "ELF64-x86-64"; | 1088 | 0 | case ELF::EM_AARCH64: | 1089 | 0 | return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big"); | 1090 | 0 | case ELF::EM_PPC64: | 1091 | 0 | return "ELF64-ppc64"; | 1092 | 0 | case ELF::EM_RISCV: | 1093 | 0 | return "ELF64-riscv"; | 1094 | 0 | case ELF::EM_S390: | 1095 | 0 | return "ELF64-s390"; | 1096 | 0 | case ELF::EM_SPARCV9: | 1097 | 0 | return "ELF64-sparc"; | 1098 | 0 | case ELF::EM_MIPS: | 1099 | 0 | return "ELF64-mips"; | 1100 | 0 | case ELF::EM_AMDGPU: | 1101 | 0 | return "ELF64-amdgpu"; | 1102 | 0 | case ELF::EM_BPF: | 1103 | 0 | return "ELF64-BPF"; | 1104 | 0 | default: | 1105 | 0 | return "ELF64-unknown"; | 1106 | 0 | } | 1107 | 0 | default: | 1108 | 0 | // FIXME: Proper error handling. | 1109 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1110 | 1.26k | } | 1111 | 1.26k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getFileFormatName() const Line | Count | Source | 1047 | 341 | StringRef ELFObjectFile<ELFT>::getFileFormatName() const { | 1048 | 341 | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1049 | 341 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1050 | 341 | case ELF::ELFCLASS32: | 1051 | 341 | switch (EF.getHeader()->e_machine) { | 1052 | 341 | case ELF::EM_386: | 1053 | 0 | return "ELF32-i386"; | 1054 | 341 | case ELF::EM_IAMCU: | 1055 | 0 | return "ELF32-iamcu"; | 1056 | 341 | case ELF::EM_X86_64: | 1057 | 1 | return "ELF32-x86-64"; | 1058 | 341 | case ELF::EM_ARM: | 1059 | 13 | return (IsLittleEndian ? "ELF32-arm-little"0 : "ELF32-arm-big"); | 1060 | 341 | case ELF::EM_AVR: | 1061 | 0 | return "ELF32-avr"; | 1062 | 341 | case ELF::EM_HEXAGON: | 1063 | 0 | return "ELF32-hexagon"; | 1064 | 341 | case ELF::EM_LANAI: | 1065 | 3 | return "ELF32-lanai"; | 1066 | 341 | case ELF::EM_MIPS: | 1067 | 259 | return "ELF32-mips"; | 1068 | 341 | case ELF::EM_MSP430: | 1069 | 0 | return "ELF32-msp430"; | 1070 | 341 | case ELF::EM_PPC: | 1071 | 55 | return "ELF32-ppc"; | 1072 | 341 | case ELF::EM_RISCV: | 1073 | 0 | return "ELF32-riscv"; | 1074 | 341 | case ELF::EM_SPARC: | 1075 | 10 | case ELF::EM_SPARC32PLUS: | 1076 | 10 | return "ELF32-sparc"; | 1077 | 10 | case ELF::EM_AMDGPU: | 1078 | 0 | return "ELF32-amdgpu"; | 1079 | 10 | default: | 1080 | 0 | return "ELF32-unknown"; | 1081 | 0 | } | 1082 | 0 | case ELF::ELFCLASS64: | 1083 | 0 | switch (EF.getHeader()->e_machine) { | 1084 | 0 | case ELF::EM_386: | 1085 | 0 | return "ELF64-i386"; | 1086 | 0 | case ELF::EM_X86_64: | 1087 | 0 | return "ELF64-x86-64"; | 1088 | 0 | case ELF::EM_AARCH64: | 1089 | 0 | return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big"); | 1090 | 0 | case ELF::EM_PPC64: | 1091 | 0 | return "ELF64-ppc64"; | 1092 | 0 | case ELF::EM_RISCV: | 1093 | 0 | return "ELF64-riscv"; | 1094 | 0 | case ELF::EM_S390: | 1095 | 0 | return "ELF64-s390"; | 1096 | 0 | case ELF::EM_SPARCV9: | 1097 | 0 | return "ELF64-sparc"; | 1098 | 0 | case ELF::EM_MIPS: | 1099 | 0 | return "ELF64-mips"; | 1100 | 0 | case ELF::EM_AMDGPU: | 1101 | 0 | return "ELF64-amdgpu"; | 1102 | 0 | case ELF::EM_BPF: | 1103 | 0 | return "ELF64-BPF"; | 1104 | 0 | default: | 1105 | 0 | return "ELF64-unknown"; | 1106 | 0 | } | 1107 | 0 | default: | 1108 | 0 | // FIXME: Proper error handling. | 1109 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1110 | 341 | } | 1111 | 341 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getFileFormatName() const Line | Count | Source | 1047 | 3.98k | StringRef ELFObjectFile<ELFT>::getFileFormatName() const { | 1048 | 3.98k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1049 | 3.98k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1050 | 3.98k | case ELF::ELFCLASS32: | 1051 | 0 | switch (EF.getHeader()->e_machine) { | 1052 | 0 | case ELF::EM_386: | 1053 | 0 | return "ELF32-i386"; | 1054 | 0 | case ELF::EM_IAMCU: | 1055 | 0 | return "ELF32-iamcu"; | 1056 | 0 | case ELF::EM_X86_64: | 1057 | 0 | return "ELF32-x86-64"; | 1058 | 0 | case ELF::EM_ARM: | 1059 | 0 | return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big"); | 1060 | 0 | case ELF::EM_AVR: | 1061 | 0 | return "ELF32-avr"; | 1062 | 0 | case ELF::EM_HEXAGON: | 1063 | 0 | return "ELF32-hexagon"; | 1064 | 0 | case ELF::EM_LANAI: | 1065 | 0 | return "ELF32-lanai"; | 1066 | 0 | case ELF::EM_MIPS: | 1067 | 0 | return "ELF32-mips"; | 1068 | 0 | case ELF::EM_MSP430: | 1069 | 0 | return "ELF32-msp430"; | 1070 | 0 | case ELF::EM_PPC: | 1071 | 0 | return "ELF32-ppc"; | 1072 | 0 | case ELF::EM_RISCV: | 1073 | 0 | return "ELF32-riscv"; | 1074 | 0 | case ELF::EM_SPARC: | 1075 | 0 | case ELF::EM_SPARC32PLUS: | 1076 | 0 | return "ELF32-sparc"; | 1077 | 0 | case ELF::EM_AMDGPU: | 1078 | 0 | return "ELF32-amdgpu"; | 1079 | 0 | default: | 1080 | 0 | return "ELF32-unknown"; | 1081 | 0 | } | 1082 | 3.98k | case ELF::ELFCLASS64: | 1083 | 3.98k | switch (EF.getHeader()->e_machine) { | 1084 | 3.98k | case ELF::EM_386: | 1085 | 2 | return "ELF64-i386"; | 1086 | 3.98k | case ELF::EM_X86_64: | 1087 | 2.27k | return "ELF64-x86-64"; | 1088 | 3.98k | case ELF::EM_AARCH64: | 1089 | 1.26k | return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big"0 ); | 1090 | 3.98k | case ELF::EM_PPC64: | 1091 | 88 | return "ELF64-ppc64"; | 1092 | 3.98k | case ELF::EM_RISCV: | 1093 | 111 | return "ELF64-riscv"; | 1094 | 3.98k | case ELF::EM_S390: | 1095 | 0 | return "ELF64-s390"; | 1096 | 3.98k | case ELF::EM_SPARCV9: | 1097 | 0 | return "ELF64-sparc"; | 1098 | 3.98k | case ELF::EM_MIPS: | 1099 | 72 | return "ELF64-mips"; | 1100 | 3.98k | case ELF::EM_AMDGPU: | 1101 | 144 | return "ELF64-amdgpu"; | 1102 | 3.98k | case ELF::EM_BPF: | 1103 | 18 | return "ELF64-BPF"; | 1104 | 3.98k | default: | 1105 | 6 | return "ELF64-unknown"; | 1106 | 0 | } | 1107 | 0 | default: | 1108 | 0 | // FIXME: Proper error handling. | 1109 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1110 | 3.98k | } | 1111 | 3.98k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getFileFormatName() const Line | Count | Source | 1047 | 213 | StringRef ELFObjectFile<ELFT>::getFileFormatName() const { | 1048 | 213 | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1049 | 213 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1050 | 213 | case ELF::ELFCLASS32: | 1051 | 0 | switch (EF.getHeader()->e_machine) { | 1052 | 0 | case ELF::EM_386: | 1053 | 0 | return "ELF32-i386"; | 1054 | 0 | case ELF::EM_IAMCU: | 1055 | 0 | return "ELF32-iamcu"; | 1056 | 0 | case ELF::EM_X86_64: | 1057 | 0 | return "ELF32-x86-64"; | 1058 | 0 | case ELF::EM_ARM: | 1059 | 0 | return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big"); | 1060 | 0 | case ELF::EM_AVR: | 1061 | 0 | return "ELF32-avr"; | 1062 | 0 | case ELF::EM_HEXAGON: | 1063 | 0 | return "ELF32-hexagon"; | 1064 | 0 | case ELF::EM_LANAI: | 1065 | 0 | return "ELF32-lanai"; | 1066 | 0 | case ELF::EM_MIPS: | 1067 | 0 | return "ELF32-mips"; | 1068 | 0 | case ELF::EM_MSP430: | 1069 | 0 | return "ELF32-msp430"; | 1070 | 0 | case ELF::EM_PPC: | 1071 | 0 | return "ELF32-ppc"; | 1072 | 0 | case ELF::EM_RISCV: | 1073 | 0 | return "ELF32-riscv"; | 1074 | 0 | case ELF::EM_SPARC: | 1075 | 0 | case ELF::EM_SPARC32PLUS: | 1076 | 0 | return "ELF32-sparc"; | 1077 | 0 | case ELF::EM_AMDGPU: | 1078 | 0 | return "ELF32-amdgpu"; | 1079 | 0 | default: | 1080 | 0 | return "ELF32-unknown"; | 1081 | 0 | } | 1082 | 213 | case ELF::ELFCLASS64: | 1083 | 213 | switch (EF.getHeader()->e_machine) { | 1084 | 213 | case ELF::EM_386: | 1085 | 0 | return "ELF64-i386"; | 1086 | 213 | case ELF::EM_X86_64: | 1087 | 2 | return "ELF64-x86-64"; | 1088 | 213 | case ELF::EM_AARCH64: | 1089 | 8 | return (IsLittleEndian ? "ELF64-aarch64-little"0 : "ELF64-aarch64-big"); | 1090 | 213 | case ELF::EM_PPC64: | 1091 | 85 | return "ELF64-ppc64"; | 1092 | 213 | case ELF::EM_RISCV: | 1093 | 0 | return "ELF64-riscv"; | 1094 | 213 | case ELF::EM_S390: | 1095 | 10 | return "ELF64-s390"; | 1096 | 213 | case ELF::EM_SPARCV9: | 1097 | 14 | return "ELF64-sparc"; | 1098 | 213 | case ELF::EM_MIPS: | 1099 | 90 | return "ELF64-mips"; | 1100 | 213 | case ELF::EM_AMDGPU: | 1101 | 0 | return "ELF64-amdgpu"; | 1102 | 213 | case ELF::EM_BPF: | 1103 | 4 | return "ELF64-BPF"; | 1104 | 213 | default: | 1105 | 0 | return "ELF64-unknown"; | 1106 | 0 | } | 1107 | 0 | default: | 1108 | 0 | // FIXME: Proper error handling. | 1109 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1110 | 213 | } | 1111 | 213 | } |
|
1112 | | |
1113 | 83.0k | template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { |
1114 | 83.0k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; |
1115 | 83.0k | switch (EF.getHeader()->e_machine) { |
1116 | 83.0k | case ELF::EM_386: |
1117 | 19.3k | case ELF::EM_IAMCU: |
1118 | 19.3k | return Triple::x86; |
1119 | 19.3k | case ELF::EM_X86_64: |
1120 | 11.1k | return Triple::x86_64; |
1121 | 20.9k | case ELF::EM_AARCH64: |
1122 | 20.9k | return IsLittleEndian ? Triple::aarch6420.9k : Triple::aarch64_be25 ; |
1123 | 19.3k | case ELF::EM_ARM: |
1124 | 14.3k | return Triple::arm; |
1125 | 19.3k | case ELF::EM_AVR: |
1126 | 0 | return Triple::avr; |
1127 | 19.3k | case ELF::EM_HEXAGON: |
1128 | 2.98k | return Triple::hexagon; |
1129 | 19.3k | case ELF::EM_LANAI: |
1130 | 10 | return Triple::lanai; |
1131 | 19.3k | case ELF::EM_MIPS: |
1132 | 3.79k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { |
1133 | 3.79k | case ELF::ELFCLASS32: |
1134 | 3.04k | return IsLittleEndian ? Triple::mipsel864 : Triple::mips2.18k ; |
1135 | 3.79k | case ELF::ELFCLASS64: |
1136 | 751 | return IsLittleEndian ? Triple::mips64el333 : Triple::mips64418 ; |
1137 | 3.79k | default: |
1138 | 0 | report_fatal_error("Invalid ELFCLASS!"); |
1139 | 0 | } |
1140 | 88 | case ELF::EM_MSP430: |
1141 | 88 | return Triple::msp430; |
1142 | 570 | case ELF::EM_PPC: |
1143 | 570 | return Triple::ppc; |
1144 | 3.26k | case ELF::EM_PPC64: |
1145 | 3.26k | return IsLittleEndian ? Triple::ppc64le1.99k : Triple::ppc641.26k ; |
1146 | 4.41k | case ELF::EM_RISCV: |
1147 | 4.41k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { |
1148 | 4.41k | case ELF::ELFCLASS32: |
1149 | 2.36k | return Triple::riscv32; |
1150 | 4.41k | case ELF::ELFCLASS64: |
1151 | 2.04k | return Triple::riscv64; |
1152 | 4.41k | default: |
1153 | 0 | report_fatal_error("Invalid ELFCLASS!"); |
1154 | 0 | } |
1155 | 62 | case ELF::EM_S390: |
1156 | 62 | return Triple::systemz; |
1157 | 0 |
|
1158 | 65 | case ELF::EM_SPARC: |
1159 | 65 | case ELF::EM_SPARC32PLUS: |
1160 | 65 | return IsLittleEndian ? Triple::sparcel14 : Triple::sparc51 ; |
1161 | 66 | case ELF::EM_SPARCV9: |
1162 | 66 | return Triple::sparcv9; |
1163 | 65 | |
1164 | 1.40k | case ELF::EM_AMDGPU: { |
1165 | 1.40k | if (!IsLittleEndian) |
1166 | 0 | return Triple::UnknownArch; |
1167 | 1.40k | |
1168 | 1.40k | unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; |
1169 | 1.40k | if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && |
1170 | 1.40k | MACH <= ELF::EF_AMDGPU_MACH_R600_LAST1.35k ) |
1171 | 105 | return Triple::r600; |
1172 | 1.30k | if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && |
1173 | 1.30k | MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST1.24k ) |
1174 | 1.24k | return Triple::amdgcn; |
1175 | 55 | |
1176 | 55 | return Triple::UnknownArch; |
1177 | 55 | } |
1178 | 55 | |
1179 | 534 | case ELF::EM_BPF: |
1180 | 534 | return IsLittleEndian ? Triple::bpfel458 : Triple::bpfeb76 ; |
1181 | 55 | |
1182 | 55 | default: |
1183 | 8 | return Triple::UnknownArch; |
1184 | 83.0k | } |
1185 | 83.0k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getArch() const Line | Count | Source | 1113 | 40.1k | template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { | 1114 | 40.1k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1115 | 40.1k | switch (EF.getHeader()->e_machine) { | 1116 | 40.1k | case ELF::EM_386: | 1117 | 19.3k | case ELF::EM_IAMCU: | 1118 | 19.3k | return Triple::x86; | 1119 | 19.3k | case ELF::EM_X86_64: | 1120 | 24 | return Triple::x86_64; | 1121 | 19.3k | case ELF::EM_AARCH64: | 1122 | 0 | return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be; | 1123 | 19.3k | case ELF::EM_ARM: | 1124 | 14.3k | return Triple::arm; | 1125 | 19.3k | case ELF::EM_AVR: | 1126 | 0 | return Triple::avr; | 1127 | 19.3k | case ELF::EM_HEXAGON: | 1128 | 2.96k | return Triple::hexagon; | 1129 | 19.3k | case ELF::EM_LANAI: | 1130 | 3 | return Triple::lanai; | 1131 | 19.3k | case ELF::EM_MIPS: | 1132 | 864 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1133 | 864 | case ELF::ELFCLASS32: | 1134 | 864 | return IsLittleEndian ? Triple::mipsel : Triple::mips0 ; | 1135 | 864 | case ELF::ELFCLASS64: | 1136 | 0 | return IsLittleEndian ? Triple::mips64el : Triple::mips64; | 1137 | 864 | default: | 1138 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1139 | 0 | } | 1140 | 88 | case ELF::EM_MSP430: | 1141 | 88 | return Triple::msp430; | 1142 | 6 | case ELF::EM_PPC: | 1143 | 6 | return Triple::ppc; | 1144 | 0 | case ELF::EM_PPC64: | 1145 | 0 | return IsLittleEndian ? Triple::ppc64le : Triple::ppc64; | 1146 | 2.36k | case ELF::EM_RISCV: | 1147 | 2.36k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1148 | 2.36k | case ELF::ELFCLASS32: | 1149 | 2.36k | return Triple::riscv32; | 1150 | 2.36k | case ELF::ELFCLASS64: | 1151 | 0 | return Triple::riscv64; | 1152 | 2.36k | default: | 1153 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1154 | 0 | } | 1155 | 0 | case ELF::EM_S390: | 1156 | 0 | return Triple::systemz; | 1157 | 0 |
| 1158 | 14 | case ELF::EM_SPARC: | 1159 | 14 | case ELF::EM_SPARC32PLUS: | 1160 | 14 | return IsLittleEndian ? Triple::sparcel : Triple::sparc0 ; | 1161 | 14 | case ELF::EM_SPARCV9: | 1162 | 0 | return Triple::sparcv9; | 1163 | 14 | | 1164 | 108 | case ELF::EM_AMDGPU: { | 1165 | 108 | if (!IsLittleEndian) | 1166 | 0 | return Triple::UnknownArch; | 1167 | 108 | | 1168 | 108 | unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; | 1169 | 108 | if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && | 1170 | 108 | MACH <= ELF::EF_AMDGPU_MACH_R600_LAST105 ) | 1171 | 105 | return Triple::r600; | 1172 | 3 | if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && | 1173 | 3 | MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST0 ) | 1174 | 0 | return Triple::amdgcn; | 1175 | 3 | | 1176 | 3 | return Triple::UnknownArch; | 1177 | 3 | } | 1178 | 3 | | 1179 | 3 | case ELF::EM_BPF: | 1180 | 0 | return IsLittleEndian ? Triple::bpfel : Triple::bpfeb; | 1181 | 3 | | 1182 | 8 | default: | 1183 | 8 | return Triple::UnknownArch; | 1184 | 40.1k | } | 1185 | 40.1k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getArch() const Line | Count | Source | 1113 | 2.82k | template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { | 1114 | 2.82k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1115 | 2.82k | switch (EF.getHeader()->e_machine) { | 1116 | 2.82k | case ELF::EM_386: | 1117 | 0 | case ELF::EM_IAMCU: | 1118 | 0 | return Triple::x86; | 1119 | 3 | case ELF::EM_X86_64: | 1120 | 3 | return Triple::x86_64; | 1121 | 0 | case ELF::EM_AARCH64: | 1122 | 0 | return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be; | 1123 | 15 | case ELF::EM_ARM: | 1124 | 15 | return Triple::arm; | 1125 | 0 | case ELF::EM_AVR: | 1126 | 0 | return Triple::avr; | 1127 | 0 | case ELF::EM_HEXAGON: | 1128 | 0 | return Triple::hexagon; | 1129 | 7 | case ELF::EM_LANAI: | 1130 | 7 | return Triple::lanai; | 1131 | 2.18k | case ELF::EM_MIPS: | 1132 | 2.18k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1133 | 2.18k | case ELF::ELFCLASS32: | 1134 | 2.18k | return IsLittleEndian ? Triple::mipsel0 : Triple::mips; | 1135 | 2.18k | case ELF::ELFCLASS64: | 1136 | 0 | return IsLittleEndian ? Triple::mips64el : Triple::mips64; | 1137 | 2.18k | default: | 1138 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1139 | 0 | } | 1140 | 0 | case ELF::EM_MSP430: | 1141 | 0 | return Triple::msp430; | 1142 | 564 | case ELF::EM_PPC: | 1143 | 564 | return Triple::ppc; | 1144 | 0 | case ELF::EM_PPC64: | 1145 | 0 | return IsLittleEndian ? Triple::ppc64le : Triple::ppc64; | 1146 | 0 | case ELF::EM_RISCV: | 1147 | 0 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1148 | 0 | case ELF::ELFCLASS32: | 1149 | 0 | return Triple::riscv32; | 1150 | 0 | case ELF::ELFCLASS64: | 1151 | 0 | return Triple::riscv64; | 1152 | 0 | default: | 1153 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1154 | 0 | } | 1155 | 0 | case ELF::EM_S390: | 1156 | 0 | return Triple::systemz; | 1157 | 0 |
| 1158 | 51 | case ELF::EM_SPARC: | 1159 | 51 | case ELF::EM_SPARC32PLUS: | 1160 | 51 | return IsLittleEndian ? Triple::sparcel0 : Triple::sparc; | 1161 | 51 | case ELF::EM_SPARCV9: | 1162 | 0 | return Triple::sparcv9; | 1163 | 51 | | 1164 | 51 | case ELF::EM_AMDGPU: { | 1165 | 0 | if (!IsLittleEndian) | 1166 | 0 | return Triple::UnknownArch; | 1167 | 0 | | 1168 | 0 | unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; | 1169 | 0 | if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && | 1170 | 0 | MACH <= ELF::EF_AMDGPU_MACH_R600_LAST) | 1171 | 0 | return Triple::r600; | 1172 | 0 | if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && | 1173 | 0 | MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST) | 1174 | 0 | return Triple::amdgcn; | 1175 | 0 | | 1176 | 0 | return Triple::UnknownArch; | 1177 | 0 | } | 1178 | 0 |
| 1179 | 0 | case ELF::EM_BPF: | 1180 | 0 | return IsLittleEndian ? Triple::bpfel : Triple::bpfeb; | 1181 | 0 |
| 1182 | 0 | default: | 1183 | 0 | return Triple::UnknownArch; | 1184 | 2.82k | } | 1185 | 2.82k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getArch() const Line | Count | Source | 1113 | 38.2k | template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { | 1114 | 38.2k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1115 | 38.2k | switch (EF.getHeader()->e_machine) { | 1116 | 38.2k | case ELF::EM_386: | 1117 | 2 | case ELF::EM_IAMCU: | 1118 | 2 | return Triple::x86; | 1119 | 11.1k | case ELF::EM_X86_64: | 1120 | 11.1k | return Triple::x86_64; | 1121 | 20.9k | case ELF::EM_AARCH64: | 1122 | 20.9k | return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be0 ; | 1123 | 8 | case ELF::EM_ARM: | 1124 | 8 | return Triple::arm; | 1125 | 2 | case ELF::EM_AVR: | 1126 | 0 | return Triple::avr; | 1127 | 11 | case ELF::EM_HEXAGON: | 1128 | 11 | return Triple::hexagon; | 1129 | 2 | case ELF::EM_LANAI: | 1130 | 0 | return Triple::lanai; | 1131 | 333 | case ELF::EM_MIPS: | 1132 | 333 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1133 | 333 | case ELF::ELFCLASS32: | 1134 | 0 | return IsLittleEndian ? Triple::mipsel : Triple::mips; | 1135 | 333 | case ELF::ELFCLASS64: | 1136 | 333 | return IsLittleEndian ? Triple::mips64el : Triple::mips640 ; | 1137 | 333 | default: | 1138 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1139 | 0 | } | 1140 | 0 | case ELF::EM_MSP430: | 1141 | 0 | return Triple::msp430; | 1142 | 0 | case ELF::EM_PPC: | 1143 | 0 | return Triple::ppc; | 1144 | 1.99k | case ELF::EM_PPC64: | 1145 | 1.99k | return IsLittleEndian ? Triple::ppc64le : Triple::ppc640 ; | 1146 | 2.04k | case ELF::EM_RISCV: | 1147 | 2.04k | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1148 | 2.04k | case ELF::ELFCLASS32: | 1149 | 0 | return Triple::riscv32; | 1150 | 2.04k | case ELF::ELFCLASS64: | 1151 | 2.04k | return Triple::riscv64; | 1152 | 2.04k | default: | 1153 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1154 | 0 | } | 1155 | 0 | case ELF::EM_S390: | 1156 | 0 | return Triple::systemz; | 1157 | 0 |
| 1158 | 0 | case ELF::EM_SPARC: | 1159 | 0 | case ELF::EM_SPARC32PLUS: | 1160 | 0 | return IsLittleEndian ? Triple::sparcel : Triple::sparc; | 1161 | 0 | case ELF::EM_SPARCV9: | 1162 | 0 | return Triple::sparcv9; | 1163 | 0 |
| 1164 | 1.29k | case ELF::EM_AMDGPU: { | 1165 | 1.29k | if (!IsLittleEndian) | 1166 | 0 | return Triple::UnknownArch; | 1167 | 1.29k | | 1168 | 1.29k | unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; | 1169 | 1.29k | if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && | 1170 | 1.29k | MACH <= ELF::EF_AMDGPU_MACH_R600_LAST1.24k ) | 1171 | 0 | return Triple::r600; | 1172 | 1.29k | if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && | 1173 | 1.29k | MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST1.24k ) | 1174 | 1.24k | return Triple::amdgcn; | 1175 | 52 | | 1176 | 52 | return Triple::UnknownArch; | 1177 | 52 | } | 1178 | 52 | | 1179 | 458 | case ELF::EM_BPF: | 1180 | 458 | return IsLittleEndian ? Triple::bpfel : Triple::bpfeb0 ; | 1181 | 52 | | 1182 | 52 | default: | 1183 | 0 | return Triple::UnknownArch; | 1184 | 38.2k | } | 1185 | 38.2k | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getArch() const Line | Count | Source | 1113 | 1.92k | template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { | 1114 | 1.92k | bool IsLittleEndian = ELFT::TargetEndianness == support::little; | 1115 | 1.92k | switch (EF.getHeader()->e_machine) { | 1116 | 1.92k | case ELF::EM_386: | 1117 | 0 | case ELF::EM_IAMCU: | 1118 | 0 | return Triple::x86; | 1119 | 6 | case ELF::EM_X86_64: | 1120 | 6 | return Triple::x86_64; | 1121 | 25 | case ELF::EM_AARCH64: | 1122 | 25 | return IsLittleEndian ? Triple::aarch640 : Triple::aarch64_be; | 1123 | 0 | case ELF::EM_ARM: | 1124 | 0 | return Triple::arm; | 1125 | 0 | case ELF::EM_AVR: | 1126 | 0 | return Triple::avr; | 1127 | 0 | case ELF::EM_HEXAGON: | 1128 | 0 | return Triple::hexagon; | 1129 | 0 | case ELF::EM_LANAI: | 1130 | 0 | return Triple::lanai; | 1131 | 418 | case ELF::EM_MIPS: | 1132 | 418 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1133 | 418 | case ELF::ELFCLASS32: | 1134 | 0 | return IsLittleEndian ? Triple::mipsel : Triple::mips; | 1135 | 418 | case ELF::ELFCLASS64: | 1136 | 418 | return IsLittleEndian ? Triple::mips64el0 : Triple::mips64; | 1137 | 418 | default: | 1138 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1139 | 0 | } | 1140 | 0 | case ELF::EM_MSP430: | 1141 | 0 | return Triple::msp430; | 1142 | 0 | case ELF::EM_PPC: | 1143 | 0 | return Triple::ppc; | 1144 | 1.26k | case ELF::EM_PPC64: | 1145 | 1.26k | return IsLittleEndian ? Triple::ppc64le0 : Triple::ppc64; | 1146 | 0 | case ELF::EM_RISCV: | 1147 | 0 | switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { | 1148 | 0 | case ELF::ELFCLASS32: | 1149 | 0 | return Triple::riscv32; | 1150 | 0 | case ELF::ELFCLASS64: | 1151 | 0 | return Triple::riscv64; | 1152 | 0 | default: | 1153 | 0 | report_fatal_error("Invalid ELFCLASS!"); | 1154 | 0 | } | 1155 | 62 | case ELF::EM_S390: | 1156 | 62 | return Triple::systemz; | 1157 | 0 |
| 1158 | 0 | case ELF::EM_SPARC: | 1159 | 0 | case ELF::EM_SPARC32PLUS: | 1160 | 0 | return IsLittleEndian ? Triple::sparcel : Triple::sparc; | 1161 | 66 | case ELF::EM_SPARCV9: | 1162 | 66 | return Triple::sparcv9; | 1163 | 0 |
| 1164 | 0 | case ELF::EM_AMDGPU: { | 1165 | 0 | if (!IsLittleEndian) | 1166 | 0 | return Triple::UnknownArch; | 1167 | 0 | | 1168 | 0 | unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; | 1169 | 0 | if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && | 1170 | 0 | MACH <= ELF::EF_AMDGPU_MACH_R600_LAST) | 1171 | 0 | return Triple::r600; | 1172 | 0 | if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && | 1173 | 0 | MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST) | 1174 | 0 | return Triple::amdgcn; | 1175 | 0 | | 1176 | 0 | return Triple::UnknownArch; | 1177 | 0 | } | 1178 | 0 |
| 1179 | 76 | case ELF::EM_BPF: | 1180 | 76 | return IsLittleEndian ? Triple::bpfel0 : Triple::bpfeb; | 1181 | 0 |
| 1182 | 0 | default: | 1183 | 0 | return Triple::UnknownArch; | 1184 | 1.92k | } | 1185 | 1.92k | } |
|
1186 | | |
1187 | | template <class ELFT> |
1188 | 11 | Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const { |
1189 | 11 | return EF.getHeader()->e_entry; |
1190 | 11 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getStartAddress() const Line | Count | Source | 1188 | 1 | Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const { | 1189 | 1 | return EF.getHeader()->e_entry; | 1190 | 1 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getStartAddress() const llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getStartAddress() const Line | Count | Source | 1188 | 10 | Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const { | 1189 | 10 | return EF.getHeader()->e_entry; | 1190 | 10 | } |
Unexecuted instantiation: llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getStartAddress() const |
1191 | | |
1192 | | template <class ELFT> |
1193 | | ELFObjectFileBase::elf_symbol_iterator_range |
1194 | 268 | ELFObjectFile<ELFT>::getDynamicSymbolIterators() const { |
1195 | 268 | return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); |
1196 | 268 | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getDynamicSymbolIterators() const Line | Count | Source | 1194 | 160 | ELFObjectFile<ELFT>::getDynamicSymbolIterators() const { | 1195 | 160 | return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); | 1196 | 160 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getDynamicSymbolIterators() const Line | Count | Source | 1194 | 7 | ELFObjectFile<ELFT>::getDynamicSymbolIterators() const { | 1195 | 7 | return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); | 1196 | 7 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getDynamicSymbolIterators() const Line | Count | Source | 1194 | 100 | ELFObjectFile<ELFT>::getDynamicSymbolIterators() const { | 1195 | 100 | return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); | 1196 | 100 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getDynamicSymbolIterators() const Line | Count | Source | 1194 | 1 | ELFObjectFile<ELFT>::getDynamicSymbolIterators() const { | 1195 | 1 | return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); | 1196 | 1 | } |
|
1197 | | |
1198 | 1.81k | template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { |
1199 | 1.81k | return EF.getHeader()->e_type == ELF::ET_REL; |
1200 | 1.81k | } llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::isRelocatableObject() const Line | Count | Source | 1198 | 798 | template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { | 1199 | 798 | return EF.getHeader()->e_type == ELF::ET_REL; | 1200 | 798 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::isRelocatableObject() const Line | Count | Source | 1198 | 182 | template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { | 1199 | 182 | return EF.getHeader()->e_type == ELF::ET_REL; | 1200 | 182 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::isRelocatableObject() const Line | Count | Source | 1198 | 823 | template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { | 1199 | 823 | return EF.getHeader()->e_type == ELF::ET_REL; | 1200 | 823 | } |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::isRelocatableObject() const Line | Count | Source | 1198 | 13 | template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { | 1199 | 13 | return EF.getHeader()->e_type == ELF::ET_REL; | 1200 | 13 | } |
|
1201 | | |
1202 | | } // end namespace object |
1203 | | } // end namespace llvm |
1204 | | |
1205 | | #endif // LLVM_OBJECT_ELFOBJECTFILE_H |