File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-readobj/ELFDumper.cpp |
Warning: | line 926, column 20 Branch condition evaluates to a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===// | |||
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 | /// \file | |||
10 | /// This file implements the ELF-specific dumper for llvm-readobj. | |||
11 | /// | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "ARMEHABIPrinter.h" | |||
15 | #include "DwarfCFIEHPrinter.h" | |||
16 | #include "ObjDumper.h" | |||
17 | #include "StackMapPrinter.h" | |||
18 | #include "llvm-readobj.h" | |||
19 | #include "llvm/ADT/ArrayRef.h" | |||
20 | #include "llvm/ADT/BitVector.h" | |||
21 | #include "llvm/ADT/DenseMap.h" | |||
22 | #include "llvm/ADT/DenseSet.h" | |||
23 | #include "llvm/ADT/MapVector.h" | |||
24 | #include "llvm/ADT/Optional.h" | |||
25 | #include "llvm/ADT/PointerIntPair.h" | |||
26 | #include "llvm/ADT/STLExtras.h" | |||
27 | #include "llvm/ADT/SmallString.h" | |||
28 | #include "llvm/ADT/SmallVector.h" | |||
29 | #include "llvm/ADT/StringExtras.h" | |||
30 | #include "llvm/ADT/StringRef.h" | |||
31 | #include "llvm/ADT/Twine.h" | |||
32 | #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h" | |||
33 | #include "llvm/BinaryFormat/ELF.h" | |||
34 | #include "llvm/BinaryFormat/MsgPackDocument.h" | |||
35 | #include "llvm/Demangle/Demangle.h" | |||
36 | #include "llvm/Object/Archive.h" | |||
37 | #include "llvm/Object/ELF.h" | |||
38 | #include "llvm/Object/ELFObjectFile.h" | |||
39 | #include "llvm/Object/ELFTypes.h" | |||
40 | #include "llvm/Object/Error.h" | |||
41 | #include "llvm/Object/ObjectFile.h" | |||
42 | #include "llvm/Object/RelocationResolver.h" | |||
43 | #include "llvm/Object/StackMapParser.h" | |||
44 | #include "llvm/Support/AMDGPUMetadata.h" | |||
45 | #include "llvm/Support/ARMAttributeParser.h" | |||
46 | #include "llvm/Support/ARMBuildAttributes.h" | |||
47 | #include "llvm/Support/Casting.h" | |||
48 | #include "llvm/Support/Compiler.h" | |||
49 | #include "llvm/Support/Endian.h" | |||
50 | #include "llvm/Support/ErrorHandling.h" | |||
51 | #include "llvm/Support/Format.h" | |||
52 | #include "llvm/Support/FormatVariadic.h" | |||
53 | #include "llvm/Support/FormattedStream.h" | |||
54 | #include "llvm/Support/LEB128.h" | |||
55 | #include "llvm/Support/MSP430AttributeParser.h" | |||
56 | #include "llvm/Support/MSP430Attributes.h" | |||
57 | #include "llvm/Support/MathExtras.h" | |||
58 | #include "llvm/Support/MipsABIFlags.h" | |||
59 | #include "llvm/Support/RISCVAttributeParser.h" | |||
60 | #include "llvm/Support/RISCVAttributes.h" | |||
61 | #include "llvm/Support/ScopedPrinter.h" | |||
62 | #include "llvm/Support/raw_ostream.h" | |||
63 | #include <algorithm> | |||
64 | #include <cinttypes> | |||
65 | #include <cstddef> | |||
66 | #include <cstdint> | |||
67 | #include <cstdlib> | |||
68 | #include <iterator> | |||
69 | #include <memory> | |||
70 | #include <string> | |||
71 | #include <system_error> | |||
72 | #include <vector> | |||
73 | ||||
74 | using namespace llvm; | |||
75 | using namespace llvm::object; | |||
76 | using namespace ELF; | |||
77 | ||||
78 | #define LLVM_READOBJ_ENUM_CASE(ns, enum)case ns::enum: return "enum"; \ | |||
79 | case ns::enum: \ | |||
80 | return #enum; | |||
81 | ||||
82 | #define ENUM_ENT(enum, altName){ "enum", altName, ELF::enum } \ | |||
83 | { #enum, altName, ELF::enum } | |||
84 | ||||
85 | #define ENUM_ENT_1(enum){ "enum", "enum", ELF::enum } \ | |||
86 | { #enum, #enum, ELF::enum } | |||
87 | ||||
88 | namespace { | |||
89 | ||||
90 | template <class ELFT> struct RelSymbol { | |||
91 | RelSymbol(const typename ELFT::Sym *S, StringRef N) | |||
92 | : Sym(S), Name(N.str()) {} | |||
93 | const typename ELFT::Sym *Sym; | |||
94 | std::string Name; | |||
95 | }; | |||
96 | ||||
97 | /// Represents a contiguous uniform range in the file. We cannot just create a | |||
98 | /// range directly because when creating one of these from the .dynamic table | |||
99 | /// the size, entity size and virtual address are different entries in arbitrary | |||
100 | /// order (DT_REL, DT_RELSZ, DT_RELENT for example). | |||
101 | struct DynRegionInfo { | |||
102 | DynRegionInfo(const Binary &Owner, const ObjDumper &D) | |||
103 | : Obj(&Owner), Dumper(&D) {} | |||
104 | DynRegionInfo(const Binary &Owner, const ObjDumper &D, const uint8_t *A, | |||
105 | uint64_t S, uint64_t ES) | |||
106 | : Addr(A), Size(S), EntSize(ES), Obj(&Owner), Dumper(&D) {} | |||
107 | ||||
108 | /// Address in current address space. | |||
109 | const uint8_t *Addr = nullptr; | |||
110 | /// Size in bytes of the region. | |||
111 | uint64_t Size = 0; | |||
112 | /// Size of each entity in the region. | |||
113 | uint64_t EntSize = 0; | |||
114 | ||||
115 | /// Owner object. Used for error reporting. | |||
116 | const Binary *Obj; | |||
117 | /// Dumper used for error reporting. | |||
118 | const ObjDumper *Dumper; | |||
119 | /// Error prefix. Used for error reporting to provide more information. | |||
120 | std::string Context; | |||
121 | /// Region size name. Used for error reporting. | |||
122 | StringRef SizePrintName = "size"; | |||
123 | /// Entry size name. Used for error reporting. If this field is empty, errors | |||
124 | /// will not mention the entry size. | |||
125 | StringRef EntSizePrintName = "entry size"; | |||
126 | ||||
127 | template <typename Type> ArrayRef<Type> getAsArrayRef() const { | |||
128 | const Type *Start = reinterpret_cast<const Type *>(Addr); | |||
129 | if (!Start) | |||
130 | return {Start, Start}; | |||
131 | ||||
132 | const uint64_t Offset = | |||
133 | Addr - (const uint8_t *)Obj->getMemoryBufferRef().getBufferStart(); | |||
134 | const uint64_t ObjSize = Obj->getMemoryBufferRef().getBufferSize(); | |||
135 | ||||
136 | if (Size > ObjSize - Offset) { | |||
137 | Dumper->reportUniqueWarning( | |||
138 | "unable to read data at 0x" + Twine::utohexstr(Offset) + | |||
139 | " of size 0x" + Twine::utohexstr(Size) + " (" + SizePrintName + | |||
140 | "): it goes past the end of the file of size 0x" + | |||
141 | Twine::utohexstr(ObjSize)); | |||
142 | return {Start, Start}; | |||
143 | } | |||
144 | ||||
145 | if (EntSize == sizeof(Type) && (Size % EntSize == 0)) | |||
146 | return {Start, Start + (Size / EntSize)}; | |||
147 | ||||
148 | std::string Msg; | |||
149 | if (!Context.empty()) | |||
150 | Msg += Context + " has "; | |||
151 | ||||
152 | Msg += ("invalid " + SizePrintName + " (0x" + Twine::utohexstr(Size) + ")") | |||
153 | .str(); | |||
154 | if (!EntSizePrintName.empty()) | |||
155 | Msg += | |||
156 | (" or " + EntSizePrintName + " (0x" + Twine::utohexstr(EntSize) + ")") | |||
157 | .str(); | |||
158 | ||||
159 | Dumper->reportUniqueWarning(Msg); | |||
160 | return {Start, Start}; | |||
161 | } | |||
162 | }; | |||
163 | ||||
164 | struct GroupMember { | |||
165 | StringRef Name; | |||
166 | uint64_t Index; | |||
167 | }; | |||
168 | ||||
169 | struct GroupSection { | |||
170 | StringRef Name; | |||
171 | std::string Signature; | |||
172 | uint64_t ShName; | |||
173 | uint64_t Index; | |||
174 | uint32_t Link; | |||
175 | uint32_t Info; | |||
176 | uint32_t Type; | |||
177 | std::vector<GroupMember> Members; | |||
178 | }; | |||
179 | ||||
180 | namespace { | |||
181 | ||||
182 | struct NoteType { | |||
183 | uint32_t ID; | |||
184 | StringRef Name; | |||
185 | }; | |||
186 | ||||
187 | } // namespace | |||
188 | ||||
189 | template <class ELFT> class Relocation { | |||
190 | public: | |||
191 | Relocation(const typename ELFT::Rel &R, bool IsMips64EL) | |||
192 | : Type(R.getType(IsMips64EL)), Symbol(R.getSymbol(IsMips64EL)), | |||
193 | Offset(R.r_offset), Info(R.r_info) {} | |||
194 | ||||
195 | Relocation(const typename ELFT::Rela &R, bool IsMips64EL) | |||
196 | : Relocation((const typename ELFT::Rel &)R, IsMips64EL) { | |||
197 | Addend = R.r_addend; | |||
198 | } | |||
199 | ||||
200 | uint32_t Type; | |||
201 | uint32_t Symbol; | |||
202 | typename ELFT::uint Offset; | |||
203 | typename ELFT::uint Info; | |||
204 | Optional<int64_t> Addend; | |||
205 | }; | |||
206 | ||||
207 | template <class ELFT> class MipsGOTParser; | |||
208 | ||||
209 | template <typename ELFT> class ELFDumper : public ObjDumper { | |||
210 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_Nhdr = typename ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator = typename ELFT::NoteIterator ; using Elf_CGProfile = typename ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Shdr_Range = typename ELFT ::ShdrRange; using Elf_Sym_Range = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using Elf_Relr_Range = typename ELFT ::RelrRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; | |||
211 | ||||
212 | public: | |||
213 | ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer); | |||
214 | ||||
215 | void printUnwindInfo() override; | |||
216 | void printNeededLibraries() override; | |||
217 | void printHashTable() override; | |||
218 | void printGnuHashTable() override; | |||
219 | void printLoadName() override; | |||
220 | void printVersionInfo() override; | |||
221 | void printArchSpecificInfo() override; | |||
222 | void printStackMap() const override; | |||
223 | ||||
224 | const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; }; | |||
225 | ||||
226 | std::string describe(const Elf_Shdr &Sec) const; | |||
227 | ||||
228 | unsigned getHashTableEntSize() const { | |||
229 | // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH | |||
230 | // sections. This violates the ELF specification. | |||
231 | if (Obj.getHeader().e_machine == ELF::EM_S390 || | |||
232 | Obj.getHeader().e_machine == ELF::EM_ALPHA) | |||
233 | return 8; | |||
234 | return 4; | |||
235 | } | |||
236 | ||||
237 | Elf_Dyn_Range dynamic_table() const { | |||
238 | // A valid .dynamic section contains an array of entries terminated | |||
239 | // with a DT_NULL entry. However, sometimes the section content may | |||
240 | // continue past the DT_NULL entry, so to dump the section correctly, | |||
241 | // we first find the end of the entries by iterating over them. | |||
242 | Elf_Dyn_Range Table = DynamicTable.template getAsArrayRef<Elf_Dyn>(); | |||
243 | ||||
244 | size_t Size = 0; | |||
245 | while (Size < Table.size()) | |||
246 | if (Table[Size++].getTag() == DT_NULL) | |||
247 | break; | |||
248 | ||||
249 | return Table.slice(0, Size); | |||
250 | } | |||
251 | ||||
252 | Elf_Sym_Range dynamic_symbols() const { | |||
253 | if (!DynSymRegion) | |||
254 | return Elf_Sym_Range(); | |||
255 | return DynSymRegion->template getAsArrayRef<Elf_Sym>(); | |||
256 | } | |||
257 | ||||
258 | const Elf_Shdr *findSectionByName(StringRef Name) const; | |||
259 | ||||
260 | StringRef getDynamicStringTable() const { return DynamicStringTable; } | |||
261 | ||||
262 | protected: | |||
263 | virtual void printVersionSymbolSection(const Elf_Shdr *Sec) = 0; | |||
264 | virtual void printVersionDefinitionSection(const Elf_Shdr *Sec) = 0; | |||
265 | virtual void printVersionDependencySection(const Elf_Shdr *Sec) = 0; | |||
266 | ||||
267 | void | |||
268 | printDependentLibsHelper(function_ref<void(const Elf_Shdr &)> OnSectionStart, | |||
269 | function_ref<void(StringRef, uint64_t)> OnLibEntry); | |||
270 | ||||
271 | virtual void printRelRelaReloc(const Relocation<ELFT> &R, | |||
272 | const RelSymbol<ELFT> &RelSym) = 0; | |||
273 | virtual void printRelrReloc(const Elf_Relr &R) = 0; | |||
274 | virtual void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
275 | const DynRegionInfo &Reg) {} | |||
276 | void printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
277 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab); | |||
278 | void printDynamicReloc(const Relocation<ELFT> &R); | |||
279 | void printDynamicRelocationsHelper(); | |||
280 | void printRelocationsHelper(const Elf_Shdr &Sec); | |||
281 | void forEachRelocationDo( | |||
282 | const Elf_Shdr &Sec, bool RawRelr, | |||
283 | llvm::function_ref<void(const Relocation<ELFT> &, unsigned, | |||
284 | const Elf_Shdr &, const Elf_Shdr *)> | |||
285 | RelRelaFn, | |||
286 | llvm::function_ref<void(const Elf_Relr &)> RelrFn); | |||
287 | ||||
288 | virtual void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
289 | bool NonVisibilityBitsUsed) const {}; | |||
290 | virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
291 | DataRegion<Elf_Word> ShndxTable, | |||
292 | Optional<StringRef> StrTable, bool IsDynamic, | |||
293 | bool NonVisibilityBitsUsed) const = 0; | |||
294 | ||||
295 | virtual void printMipsABIFlags() = 0; | |||
296 | virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
297 | virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
298 | ||||
299 | Expected<ArrayRef<Elf_Versym>> | |||
300 | getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
301 | StringRef *StrTab, const Elf_Shdr **SymTabSec) const; | |||
302 | StringRef getPrintableSectionName(const Elf_Shdr &Sec) const; | |||
303 | ||||
304 | std::vector<GroupSection> getGroups(); | |||
305 | ||||
306 | // Returns the function symbol index for the given address. Matches the | |||
307 | // symbol's section with FunctionSec when specified. | |||
308 | // Returns None if no function symbol can be found for the address or in case | |||
309 | // it is not defined in the specified section. | |||
310 | SmallVector<uint32_t> | |||
311 | getSymbolIndexesForFunctionAddress(uint64_t SymValue, | |||
312 | Optional<const Elf_Shdr *> FunctionSec); | |||
313 | bool printFunctionStackSize(uint64_t SymValue, | |||
314 | Optional<const Elf_Shdr *> FunctionSec, | |||
315 | const Elf_Shdr &StackSizeSec, DataExtractor Data, | |||
316 | uint64_t *Offset); | |||
317 | void printStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec, | |||
318 | unsigned Ndx, const Elf_Shdr *SymTab, | |||
319 | const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec, | |||
320 | const RelocationResolver &Resolver, DataExtractor Data); | |||
321 | virtual void printStackSizeEntry(uint64_t Size, | |||
322 | ArrayRef<std::string> FuncNames) = 0; | |||
323 | ||||
324 | void printRelocatableStackSizes(std::function<void()> PrintHeader); | |||
325 | void printNonRelocatableStackSizes(std::function<void()> PrintHeader); | |||
326 | ||||
327 | /// Retrieves sections with corresponding relocation sections based on | |||
328 | /// IsMatch. | |||
329 | void getSectionAndRelocations( | |||
330 | std::function<bool(const Elf_Shdr &)> IsMatch, | |||
331 | llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap); | |||
332 | ||||
333 | const object::ELFObjectFile<ELFT> &ObjF; | |||
334 | const ELFFile<ELFT> &Obj; | |||
335 | StringRef FileName; | |||
336 | ||||
337 | Expected<DynRegionInfo> createDRI(uint64_t Offset, uint64_t Size, | |||
338 | uint64_t EntSize) { | |||
339 | if (Offset + Size < Offset || Offset + Size > Obj.getBufSize()) | |||
340 | return createError("offset (0x" + Twine::utohexstr(Offset) + | |||
341 | ") + size (0x" + Twine::utohexstr(Size) + | |||
342 | ") is greater than the file size (0x" + | |||
343 | Twine::utohexstr(Obj.getBufSize()) + ")"); | |||
344 | return DynRegionInfo(ObjF, *this, Obj.base() + Offset, Size, EntSize); | |||
345 | } | |||
346 | ||||
347 | void printAttributes(unsigned, std::unique_ptr<ELFAttributeParser>, | |||
348 | support::endianness); | |||
349 | void printMipsReginfo(); | |||
350 | void printMipsOptions(); | |||
351 | ||||
352 | std::pair<const Elf_Phdr *, const Elf_Shdr *> findDynamic(); | |||
353 | void loadDynamicTable(); | |||
354 | void parseDynamicTable(); | |||
355 | ||||
356 | Expected<StringRef> getSymbolVersion(const Elf_Sym &Sym, | |||
357 | bool &IsDefault) const; | |||
358 | Expected<SmallVector<Optional<VersionEntry>, 0> *> getVersionMap() const; | |||
359 | ||||
360 | DynRegionInfo DynRelRegion; | |||
361 | DynRegionInfo DynRelaRegion; | |||
362 | DynRegionInfo DynRelrRegion; | |||
363 | DynRegionInfo DynPLTRelRegion; | |||
364 | Optional<DynRegionInfo> DynSymRegion; | |||
365 | DynRegionInfo DynSymTabShndxRegion; | |||
366 | DynRegionInfo DynamicTable; | |||
367 | StringRef DynamicStringTable; | |||
368 | const Elf_Hash *HashTable = nullptr; | |||
369 | const Elf_GnuHash *GnuHashTable = nullptr; | |||
370 | const Elf_Shdr *DotSymtabSec = nullptr; | |||
371 | const Elf_Shdr *DotDynsymSec = nullptr; | |||
372 | const Elf_Shdr *DotAddrsigSec = nullptr; | |||
373 | DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables; | |||
374 | Optional<uint64_t> SONameOffset; | |||
375 | Optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap; | |||
376 | ||||
377 | const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version | |||
378 | const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r | |||
379 | const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d | |||
380 | ||||
381 | std::string getFullSymbolName(const Elf_Sym &Symbol, unsigned SymIndex, | |||
382 | DataRegion<Elf_Word> ShndxTable, | |||
383 | Optional<StringRef> StrTable, | |||
384 | bool IsDynamic) const; | |||
385 | Expected<unsigned> | |||
386 | getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
387 | DataRegion<Elf_Word> ShndxTable) const; | |||
388 | Expected<StringRef> getSymbolSectionName(const Elf_Sym &Symbol, | |||
389 | unsigned SectionIndex) const; | |||
390 | std::string getStaticSymbolName(uint32_t Index) const; | |||
391 | StringRef getDynamicString(uint64_t Value) const; | |||
392 | ||||
393 | void printSymbolsHelper(bool IsDynamic) const; | |||
394 | std::string getDynamicEntry(uint64_t Type, uint64_t Value) const; | |||
395 | ||||
396 | Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<ELFT> &R, | |||
397 | const Elf_Shdr *SymTab) const; | |||
398 | ||||
399 | ArrayRef<Elf_Word> getShndxTable(const Elf_Shdr *Symtab) const; | |||
400 | ||||
401 | private: | |||
402 | mutable SmallVector<Optional<VersionEntry>, 0> VersionMap; | |||
403 | }; | |||
404 | ||||
405 | template <class ELFT> | |||
406 | std::string ELFDumper<ELFT>::describe(const Elf_Shdr &Sec) const { | |||
407 | return ::describe(Obj, Sec); | |||
408 | } | |||
409 | ||||
410 | namespace { | |||
411 | ||||
412 | template <class ELFT> struct SymtabLink { | |||
413 | typename ELFT::SymRange Symbols; | |||
414 | StringRef StringTable; | |||
415 | const typename ELFT::Shdr *SymTab; | |||
416 | }; | |||
417 | ||||
418 | // Returns the linked symbol table, symbols and associated string table for a | |||
419 | // given section. | |||
420 | template <class ELFT> | |||
421 | Expected<SymtabLink<ELFT>> getLinkAsSymtab(const ELFFile<ELFT> &Obj, | |||
422 | const typename ELFT::Shdr &Sec, | |||
423 | unsigned ExpectedType) { | |||
424 | Expected<const typename ELFT::Shdr *> SymtabOrErr = | |||
425 | Obj.getSection(Sec.sh_link); | |||
426 | if (!SymtabOrErr) | |||
427 | return createError("invalid section linked to " + describe(Obj, Sec) + | |||
428 | ": " + toString(SymtabOrErr.takeError())); | |||
429 | ||||
430 | if ((*SymtabOrErr)->sh_type != ExpectedType) | |||
431 | return createError( | |||
432 | "invalid section linked to " + describe(Obj, Sec) + ": expected " + | |||
433 | object::getELFSectionTypeName(Obj.getHeader().e_machine, ExpectedType) + | |||
434 | ", but got " + | |||
435 | object::getELFSectionTypeName(Obj.getHeader().e_machine, | |||
436 | (*SymtabOrErr)->sh_type)); | |||
437 | ||||
438 | Expected<StringRef> StrTabOrErr = Obj.getLinkAsStrtab(**SymtabOrErr); | |||
439 | if (!StrTabOrErr) | |||
440 | return createError( | |||
441 | "can't get a string table for the symbol table linked to " + | |||
442 | describe(Obj, Sec) + ": " + toString(StrTabOrErr.takeError())); | |||
443 | ||||
444 | Expected<typename ELFT::SymRange> SymsOrErr = Obj.symbols(*SymtabOrErr); | |||
445 | if (!SymsOrErr) | |||
446 | return createError("unable to read symbols from the " + describe(Obj, Sec) + | |||
447 | ": " + toString(SymsOrErr.takeError())); | |||
448 | ||||
449 | return SymtabLink<ELFT>{*SymsOrErr, *StrTabOrErr, *SymtabOrErr}; | |||
450 | } | |||
451 | ||||
452 | } // namespace | |||
453 | ||||
454 | template <class ELFT> | |||
455 | Expected<ArrayRef<typename ELFT::Versym>> | |||
456 | ELFDumper<ELFT>::getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
457 | StringRef *StrTab, | |||
458 | const Elf_Shdr **SymTabSec) const { | |||
459 | assert((!SymTab && !StrTab && !SymTabSec) || (SymTab && StrTab && SymTabSec))(static_cast <bool> ((!SymTab && !StrTab && !SymTabSec) || (SymTab && StrTab && SymTabSec )) ? void (0) : __assert_fail ("(!SymTab && !StrTab && !SymTabSec) || (SymTab && StrTab && SymTabSec)" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 459, __extension__ __PRETTY_FUNCTION__)); | |||
460 | if (reinterpret_cast<uintptr_t>(Obj.base() + Sec.sh_offset) % | |||
461 | sizeof(uint16_t) != | |||
462 | 0) | |||
463 | return createError("the " + describe(Sec) + " is misaligned"); | |||
464 | ||||
465 | Expected<ArrayRef<Elf_Versym>> VersionsOrErr = | |||
466 | Obj.template getSectionContentsAsArray<Elf_Versym>(Sec); | |||
467 | if (!VersionsOrErr) | |||
468 | return createError("cannot read content of " + describe(Sec) + ": " + | |||
469 | toString(VersionsOrErr.takeError())); | |||
470 | ||||
471 | Expected<SymtabLink<ELFT>> SymTabOrErr = | |||
472 | getLinkAsSymtab(Obj, Sec, SHT_DYNSYM); | |||
473 | if (!SymTabOrErr) { | |||
474 | reportUniqueWarning(SymTabOrErr.takeError()); | |||
475 | return *VersionsOrErr; | |||
476 | } | |||
477 | ||||
478 | if (SymTabOrErr->Symbols.size() != VersionsOrErr->size()) | |||
479 | reportUniqueWarning(describe(Sec) + ": the number of entries (" + | |||
480 | Twine(VersionsOrErr->size()) + | |||
481 | ") does not match the number of symbols (" + | |||
482 | Twine(SymTabOrErr->Symbols.size()) + | |||
483 | ") in the symbol table with index " + | |||
484 | Twine(Sec.sh_link)); | |||
485 | ||||
486 | if (SymTab) { | |||
487 | *SymTab = SymTabOrErr->Symbols; | |||
488 | *StrTab = SymTabOrErr->StringTable; | |||
489 | *SymTabSec = SymTabOrErr->SymTab; | |||
490 | } | |||
491 | return *VersionsOrErr; | |||
492 | } | |||
493 | ||||
494 | template <class ELFT> | |||
495 | void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const { | |||
496 | Optional<StringRef> StrTable; | |||
497 | size_t Entries = 0; | |||
498 | Elf_Sym_Range Syms(nullptr, nullptr); | |||
499 | const Elf_Shdr *SymtabSec = IsDynamic ? DotDynsymSec : DotSymtabSec; | |||
500 | ||||
501 | if (IsDynamic) { | |||
502 | StrTable = DynamicStringTable; | |||
503 | Syms = dynamic_symbols(); | |||
504 | Entries = Syms.size(); | |||
505 | } else if (DotSymtabSec) { | |||
506 | if (Expected<StringRef> StrTableOrErr = | |||
507 | Obj.getStringTableForSymtab(*DotSymtabSec)) | |||
508 | StrTable = *StrTableOrErr; | |||
509 | else | |||
510 | reportUniqueWarning( | |||
511 | "unable to get the string table for the SHT_SYMTAB section: " + | |||
512 | toString(StrTableOrErr.takeError())); | |||
513 | ||||
514 | if (Expected<Elf_Sym_Range> SymsOrErr = Obj.symbols(DotSymtabSec)) | |||
515 | Syms = *SymsOrErr; | |||
516 | else | |||
517 | reportUniqueWarning( | |||
518 | "unable to read symbols from the SHT_SYMTAB section: " + | |||
519 | toString(SymsOrErr.takeError())); | |||
520 | Entries = DotSymtabSec->getEntityCount(); | |||
521 | } | |||
522 | if (Syms.empty()) | |||
523 | return; | |||
524 | ||||
525 | // The st_other field has 2 logical parts. The first two bits hold the symbol | |||
526 | // visibility (STV_*) and the remainder hold other platform-specific values. | |||
527 | bool NonVisibilityBitsUsed = | |||
528 | llvm::any_of(Syms, [](const Elf_Sym &S) { return S.st_other & ~0x3; }); | |||
529 | ||||
530 | DataRegion<Elf_Word> ShndxTable = | |||
531 | IsDynamic ? DataRegion<Elf_Word>( | |||
532 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, | |||
533 | this->getElfObject().getELFFile().end()) | |||
534 | : DataRegion<Elf_Word>(this->getShndxTable(SymtabSec)); | |||
535 | ||||
536 | printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed); | |||
537 | for (const Elf_Sym &Sym : Syms) | |||
538 | printSymbol(Sym, &Sym - Syms.begin(), ShndxTable, StrTable, IsDynamic, | |||
539 | NonVisibilityBitsUsed); | |||
540 | } | |||
541 | ||||
542 | template <typename ELFT> class GNUELFDumper : public ELFDumper<ELFT> { | |||
543 | formatted_raw_ostream &OS; | |||
544 | ||||
545 | public: | |||
546 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_Nhdr = typename ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator = typename ELFT::NoteIterator ; using Elf_CGProfile = typename ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Shdr_Range = typename ELFT ::ShdrRange; using Elf_Sym_Range = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using Elf_Relr_Range = typename ELFT ::RelrRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; | |||
547 | ||||
548 | GNUELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
549 | : ELFDumper<ELFT>(ObjF, Writer), | |||
550 | OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())) { | |||
551 | assert(&this->W.getOStream() == &llvm::fouts())(static_cast <bool> (&this->W.getOStream() == & llvm::fouts()) ? void (0) : __assert_fail ("&this->W.getOStream() == &llvm::fouts()" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 551, __extension__ __PRETTY_FUNCTION__)); | |||
552 | } | |||
553 | ||||
554 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
555 | ArrayRef<std::string> InputFilenames, | |||
556 | const Archive *A) override; | |||
557 | void printFileHeaders() override; | |||
558 | void printGroupSections() override; | |||
559 | void printRelocations() override; | |||
560 | void printSectionHeaders() override; | |||
561 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
562 | void printHashSymbols() override; | |||
563 | void printSectionDetails() override; | |||
564 | void printDependentLibs() override; | |||
565 | void printDynamicTable() override; | |||
566 | void printDynamicRelocations() override; | |||
567 | void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
568 | bool NonVisibilityBitsUsed) const override; | |||
569 | void printProgramHeaders(bool PrintProgramHeaders, | |||
570 | cl::boolOrDefault PrintSectionMapping) override; | |||
571 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
572 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
573 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
574 | void printHashHistograms() override; | |||
575 | void printCGProfile() override; | |||
576 | void printBBAddrMaps() override; | |||
577 | void printAddrsig() override; | |||
578 | void printNotes() override; | |||
579 | void printELFLinkerOptions() override; | |||
580 | void printStackSizes() override; | |||
581 | ||||
582 | private: | |||
583 | void printHashHistogram(const Elf_Hash &HashTable); | |||
584 | void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable); | |||
585 | void printHashTableSymbols(const Elf_Hash &HashTable); | |||
586 | void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable); | |||
587 | ||||
588 | struct Field { | |||
589 | std::string Str; | |||
590 | unsigned Column; | |||
591 | ||||
592 | Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {} | |||
593 | Field(unsigned Col) : Column(Col) {} | |||
594 | }; | |||
595 | ||||
596 | template <typename T, typename TEnum> | |||
597 | std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues, | |||
598 | TEnum EnumMask1 = {}, TEnum EnumMask2 = {}, | |||
599 | TEnum EnumMask3 = {}) const { | |||
600 | std::string Str; | |||
601 | for (const EnumEntry<TEnum> &Flag : EnumValues) { | |||
602 | if (Flag.Value == 0) | |||
603 | continue; | |||
604 | ||||
605 | TEnum EnumMask{}; | |||
606 | if (Flag.Value & EnumMask1) | |||
607 | EnumMask = EnumMask1; | |||
608 | else if (Flag.Value & EnumMask2) | |||
609 | EnumMask = EnumMask2; | |||
610 | else if (Flag.Value & EnumMask3) | |||
611 | EnumMask = EnumMask3; | |||
612 | bool IsEnum = (Flag.Value & EnumMask) != 0; | |||
613 | if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || | |||
614 | (IsEnum && (Value & EnumMask) == Flag.Value)) { | |||
615 | if (!Str.empty()) | |||
616 | Str += ", "; | |||
617 | Str += Flag.AltName; | |||
618 | } | |||
619 | } | |||
620 | return Str; | |||
621 | } | |||
622 | ||||
623 | formatted_raw_ostream &printField(struct Field F) const { | |||
624 | if (F.Column != 0) | |||
625 | OS.PadToColumn(F.Column); | |||
626 | OS << F.Str; | |||
627 | OS.flush(); | |||
628 | return OS; | |||
629 | } | |||
630 | void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex, | |||
631 | DataRegion<Elf_Word> ShndxTable, StringRef StrTable, | |||
632 | uint32_t Bucket); | |||
633 | void printRelrReloc(const Elf_Relr &R) override; | |||
634 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
635 | const RelSymbol<ELFT> &RelSym) override; | |||
636 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
637 | DataRegion<Elf_Word> ShndxTable, | |||
638 | Optional<StringRef> StrTable, bool IsDynamic, | |||
639 | bool NonVisibilityBitsUsed) const override; | |||
640 | void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
641 | const DynRegionInfo &Reg) override; | |||
642 | ||||
643 | std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex, | |||
644 | DataRegion<Elf_Word> ShndxTable) const; | |||
645 | void printProgramHeaders() override; | |||
646 | void printSectionMapping() override; | |||
647 | void printGNUVersionSectionProlog(const typename ELFT::Shdr &Sec, | |||
648 | const Twine &Label, unsigned EntriesNum); | |||
649 | ||||
650 | void printStackSizeEntry(uint64_t Size, | |||
651 | ArrayRef<std::string> FuncNames) override; | |||
652 | ||||
653 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
654 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
655 | void printMipsABIFlags() override; | |||
656 | }; | |||
657 | ||||
658 | template <typename ELFT> class LLVMELFDumper : public ELFDumper<ELFT> { | |||
659 | public: | |||
660 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_Nhdr = typename ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator = typename ELFT::NoteIterator ; using Elf_CGProfile = typename ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Shdr_Range = typename ELFT ::ShdrRange; using Elf_Sym_Range = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using Elf_Relr_Range = typename ELFT ::RelrRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; | |||
661 | ||||
662 | LLVMELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
663 | : ELFDumper<ELFT>(ObjF, Writer), W(Writer) {} | |||
664 | ||||
665 | void printFileHeaders() override; | |||
666 | void printGroupSections() override; | |||
667 | void printRelocations() override; | |||
668 | void printSectionHeaders() override; | |||
669 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
670 | void printDependentLibs() override; | |||
671 | void printDynamicTable() override; | |||
672 | void printDynamicRelocations() override; | |||
673 | void printProgramHeaders(bool PrintProgramHeaders, | |||
674 | cl::boolOrDefault PrintSectionMapping) override; | |||
675 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
676 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
677 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
678 | void printHashHistograms() override; | |||
679 | void printCGProfile() override; | |||
680 | void printBBAddrMaps() override; | |||
681 | void printAddrsig() override; | |||
682 | void printNotes() override; | |||
683 | void printELFLinkerOptions() override; | |||
684 | void printStackSizes() override; | |||
685 | ||||
686 | private: | |||
687 | void printRelrReloc(const Elf_Relr &R) override; | |||
688 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
689 | const RelSymbol<ELFT> &RelSym) override; | |||
690 | ||||
691 | void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex, | |||
692 | DataRegion<Elf_Word> ShndxTable) const; | |||
693 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
694 | DataRegion<Elf_Word> ShndxTable, | |||
695 | Optional<StringRef> StrTable, bool IsDynamic, | |||
696 | bool /*NonVisibilityBitsUsed*/) const override; | |||
697 | void printProgramHeaders() override; | |||
698 | void printSectionMapping() override {} | |||
699 | void printStackSizeEntry(uint64_t Size, | |||
700 | ArrayRef<std::string> FuncNames) override; | |||
701 | ||||
702 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
703 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
704 | void printMipsABIFlags() override; | |||
705 | ||||
706 | protected: | |||
707 | ScopedPrinter &W; | |||
708 | }; | |||
709 | ||||
710 | // JSONELFDumper shares most of the same implementation as LLVMELFDumper except | |||
711 | // it uses a JSONScopedPrinter. | |||
712 | template <typename ELFT> class JSONELFDumper : public LLVMELFDumper<ELFT> { | |||
713 | public: | |||
714 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_Nhdr = typename ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator = typename ELFT::NoteIterator ; using Elf_CGProfile = typename ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Shdr_Range = typename ELFT ::ShdrRange; using Elf_Sym_Range = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using Elf_Relr_Range = typename ELFT ::RelrRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; | |||
715 | ||||
716 | JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
717 | : LLVMELFDumper<ELFT>(ObjF, Writer) {} | |||
718 | ||||
719 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
720 | ArrayRef<std::string> InputFilenames, | |||
721 | const Archive *A) override; | |||
722 | ||||
723 | private: | |||
724 | std::unique_ptr<DictScope> FileScope; | |||
725 | }; | |||
726 | ||||
727 | } // end anonymous namespace | |||
728 | ||||
729 | namespace llvm { | |||
730 | ||||
731 | template <class ELFT> | |||
732 | static std::unique_ptr<ObjDumper> | |||
733 | createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) { | |||
734 | if (opts::Output == opts::GNU) | |||
735 | return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer); | |||
736 | else if (opts::Output == opts::JSON) | |||
737 | return std::make_unique<JSONELFDumper<ELFT>>(Obj, Writer); | |||
738 | return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer); | |||
739 | } | |||
740 | ||||
741 | std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj, | |||
742 | ScopedPrinter &Writer) { | |||
743 | // Little-endian 32-bit | |||
744 | if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj)) | |||
745 | return createELFDumper(*ELFObj, Writer); | |||
746 | ||||
747 | // Big-endian 32-bit | |||
748 | if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj)) | |||
749 | return createELFDumper(*ELFObj, Writer); | |||
750 | ||||
751 | // Little-endian 64-bit | |||
752 | if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj)) | |||
753 | return createELFDumper(*ELFObj, Writer); | |||
754 | ||||
755 | // Big-endian 64-bit | |||
756 | return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer); | |||
757 | } | |||
758 | ||||
759 | } // end namespace llvm | |||
760 | ||||
761 | template <class ELFT> | |||
762 | Expected<SmallVector<Optional<VersionEntry>, 0> *> | |||
763 | ELFDumper<ELFT>::getVersionMap() const { | |||
764 | // If the VersionMap has already been loaded or if there is no dynamic symtab | |||
765 | // or version table, there is nothing to do. | |||
766 | if (!VersionMap.empty() || !DynSymRegion || !SymbolVersionSection) | |||
767 | return &VersionMap; | |||
768 | ||||
769 | Expected<SmallVector<Optional<VersionEntry>, 0>> MapOrErr = | |||
770 | Obj.loadVersionMap(SymbolVersionNeedSection, SymbolVersionDefSection); | |||
771 | if (MapOrErr) | |||
772 | VersionMap = *MapOrErr; | |||
773 | else | |||
774 | return MapOrErr.takeError(); | |||
775 | ||||
776 | return &VersionMap; | |||
777 | } | |||
778 | ||||
779 | template <typename ELFT> | |||
780 | Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym &Sym, | |||
781 | bool &IsDefault) const { | |||
782 | // This is a dynamic symbol. Look in the GNU symbol version table. | |||
783 | if (!SymbolVersionSection) { | |||
784 | // No version table. | |||
785 | IsDefault = false; | |||
786 | return ""; | |||
787 | } | |||
788 | ||||
789 | assert(DynSymRegion && "DynSymRegion has not been initialised")(static_cast <bool> (DynSymRegion && "DynSymRegion has not been initialised" ) ? void (0) : __assert_fail ("DynSymRegion && \"DynSymRegion has not been initialised\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 789, __extension__ __PRETTY_FUNCTION__)); | |||
790 | // Determine the position in the symbol table of this entry. | |||
791 | size_t EntryIndex = (reinterpret_cast<uintptr_t>(&Sym) - | |||
792 | reinterpret_cast<uintptr_t>(DynSymRegion->Addr)) / | |||
793 | sizeof(Elf_Sym); | |||
794 | ||||
795 | // Get the corresponding version index entry. | |||
796 | Expected<const Elf_Versym *> EntryOrErr = | |||
797 | Obj.template getEntry<Elf_Versym>(*SymbolVersionSection, EntryIndex); | |||
798 | if (!EntryOrErr) | |||
799 | return EntryOrErr.takeError(); | |||
800 | ||||
801 | unsigned Version = (*EntryOrErr)->vs_index; | |||
802 | if (Version == VER_NDX_LOCAL || Version == VER_NDX_GLOBAL) { | |||
803 | IsDefault = false; | |||
804 | return ""; | |||
805 | } | |||
806 | ||||
807 | Expected<SmallVector<Optional<VersionEntry>, 0> *> MapOrErr = | |||
808 | getVersionMap(); | |||
809 | if (!MapOrErr) | |||
810 | return MapOrErr.takeError(); | |||
811 | ||||
812 | return Obj.getSymbolVersionByIndex(Version, IsDefault, **MapOrErr, | |||
813 | Sym.st_shndx == ELF::SHN_UNDEF); | |||
814 | } | |||
815 | ||||
816 | template <typename ELFT> | |||
817 | Expected<RelSymbol<ELFT>> | |||
818 | ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R, | |||
819 | const Elf_Shdr *SymTab) const { | |||
820 | if (R.Symbol == 0) | |||
821 | return RelSymbol<ELFT>(nullptr, ""); | |||
822 | ||||
823 | Expected<const Elf_Sym *> SymOrErr = | |||
824 | Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol); | |||
825 | if (!SymOrErr) | |||
826 | return createError("unable to read an entry with index " + Twine(R.Symbol) + | |||
827 | " from " + describe(*SymTab) + ": " + | |||
828 | toString(SymOrErr.takeError())); | |||
829 | const Elf_Sym *Sym = *SymOrErr; | |||
830 | if (!Sym) | |||
831 | return RelSymbol<ELFT>(nullptr, ""); | |||
832 | ||||
833 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*SymTab); | |||
834 | if (!StrTableOrErr) | |||
835 | return StrTableOrErr.takeError(); | |||
836 | ||||
837 | const Elf_Sym *FirstSym = | |||
838 | cantFail(Obj.template getEntry<Elf_Sym>(*SymTab, 0)); | |||
839 | std::string SymbolName = | |||
840 | getFullSymbolName(*Sym, Sym - FirstSym, getShndxTable(SymTab), | |||
841 | *StrTableOrErr, SymTab->sh_type == SHT_DYNSYM); | |||
842 | return RelSymbol<ELFT>(Sym, SymbolName); | |||
843 | } | |||
844 | ||||
845 | template <typename ELFT> | |||
846 | ArrayRef<typename ELFT::Word> | |||
847 | ELFDumper<ELFT>::getShndxTable(const Elf_Shdr *Symtab) const { | |||
848 | if (Symtab) { | |||
849 | auto It = ShndxTables.find(Symtab); | |||
850 | if (It != ShndxTables.end()) | |||
851 | return It->second; | |||
852 | } | |||
853 | return {}; | |||
854 | } | |||
855 | ||||
856 | static std::string maybeDemangle(StringRef Name) { | |||
857 | return opts::Demangle ? demangle(std::string(Name)) : Name.str(); | |||
858 | } | |||
859 | ||||
860 | template <typename ELFT> | |||
861 | std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const { | |||
862 | auto Warn = [&](Error E) -> std::string { | |||
863 | reportUniqueWarning("unable to read the name of symbol with index " + | |||
864 | Twine(Index) + ": " + toString(std::move(E))); | |||
865 | return "<?>"; | |||
866 | }; | |||
867 | ||||
868 | Expected<const typename ELFT::Sym *> SymOrErr = | |||
869 | Obj.getSymbol(DotSymtabSec, Index); | |||
870 | if (!SymOrErr) | |||
871 | return Warn(SymOrErr.takeError()); | |||
872 | ||||
873 | Expected<StringRef> StrTabOrErr = Obj.getStringTableForSymtab(*DotSymtabSec); | |||
874 | if (!StrTabOrErr) | |||
875 | return Warn(StrTabOrErr.takeError()); | |||
876 | ||||
877 | Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr); | |||
878 | if (!NameOrErr) | |||
879 | return Warn(NameOrErr.takeError()); | |||
880 | return maybeDemangle(*NameOrErr); | |||
881 | } | |||
882 | ||||
883 | template <typename ELFT> | |||
884 | std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym &Symbol, | |||
885 | unsigned SymIndex, | |||
886 | DataRegion<Elf_Word> ShndxTable, | |||
887 | Optional<StringRef> StrTable, | |||
888 | bool IsDynamic) const { | |||
889 | if (!StrTable) | |||
890 | return "<?>"; | |||
891 | ||||
892 | std::string SymbolName; | |||
893 | if (Expected<StringRef> NameOrErr = Symbol.getName(*StrTable)) { | |||
894 | SymbolName = maybeDemangle(*NameOrErr); | |||
895 | } else { | |||
896 | reportUniqueWarning(NameOrErr.takeError()); | |||
897 | return "<?>"; | |||
898 | } | |||
899 | ||||
900 | if (SymbolName.empty() && Symbol.getType() == ELF::STT_SECTION) { | |||
901 | Expected<unsigned> SectionIndex = | |||
902 | getSymbolSectionIndex(Symbol, SymIndex, ShndxTable); | |||
903 | if (!SectionIndex) { | |||
904 | reportUniqueWarning(SectionIndex.takeError()); | |||
905 | return "<?>"; | |||
906 | } | |||
907 | Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex); | |||
908 | if (!NameOrErr) { | |||
909 | reportUniqueWarning(NameOrErr.takeError()); | |||
910 | return ("<section " + Twine(*SectionIndex) + ">").str(); | |||
911 | } | |||
912 | return std::string(*NameOrErr); | |||
913 | } | |||
914 | ||||
915 | if (!IsDynamic
| |||
916 | return SymbolName; | |||
917 | ||||
918 | bool IsDefault; | |||
919 | Expected<StringRef> VersionOrErr = getSymbolVersion(Symbol, IsDefault); | |||
920 | if (!VersionOrErr) { | |||
921 | reportUniqueWarning(VersionOrErr.takeError()); | |||
922 | return SymbolName + "@<corrupt>"; | |||
923 | } | |||
924 | ||||
925 | if (!VersionOrErr->empty()) { | |||
926 | SymbolName += (IsDefault ? "@@" : "@"); | |||
| ||||
927 | SymbolName += *VersionOrErr; | |||
928 | } | |||
929 | return SymbolName; | |||
930 | } | |||
931 | ||||
932 | template <typename ELFT> | |||
933 | Expected<unsigned> | |||
934 | ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
935 | DataRegion<Elf_Word> ShndxTable) const { | |||
936 | unsigned Ndx = Symbol.st_shndx; | |||
937 | if (Ndx == SHN_XINDEX) | |||
938 | return object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, | |||
939 | ShndxTable); | |||
940 | if (Ndx != SHN_UNDEF && Ndx < SHN_LORESERVE) | |||
941 | return Ndx; | |||
942 | ||||
943 | auto CreateErr = [&](const Twine &Name, Optional<unsigned> Offset = None) { | |||
944 | std::string Desc; | |||
945 | if (Offset) | |||
946 | Desc = (Name + "+0x" + Twine::utohexstr(*Offset)).str(); | |||
947 | else | |||
948 | Desc = Name.str(); | |||
949 | return createError( | |||
950 | "unable to get section index for symbol with st_shndx = 0x" + | |||
951 | Twine::utohexstr(Ndx) + " (" + Desc + ")"); | |||
952 | }; | |||
953 | ||||
954 | if (Ndx >= ELF::SHN_LOPROC && Ndx <= ELF::SHN_HIPROC) | |||
955 | return CreateErr("SHN_LOPROC", Ndx - ELF::SHN_LOPROC); | |||
956 | if (Ndx >= ELF::SHN_LOOS && Ndx <= ELF::SHN_HIOS) | |||
957 | return CreateErr("SHN_LOOS", Ndx - ELF::SHN_LOOS); | |||
958 | if (Ndx == ELF::SHN_UNDEF) | |||
959 | return CreateErr("SHN_UNDEF"); | |||
960 | if (Ndx == ELF::SHN_ABS) | |||
961 | return CreateErr("SHN_ABS"); | |||
962 | if (Ndx == ELF::SHN_COMMON) | |||
963 | return CreateErr("SHN_COMMON"); | |||
964 | return CreateErr("SHN_LORESERVE", Ndx - SHN_LORESERVE); | |||
965 | } | |||
966 | ||||
967 | template <typename ELFT> | |||
968 | Expected<StringRef> | |||
969 | ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym &Symbol, | |||
970 | unsigned SectionIndex) const { | |||
971 | Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(SectionIndex); | |||
972 | if (!SecOrErr) | |||
973 | return SecOrErr.takeError(); | |||
974 | return Obj.getSectionName(**SecOrErr); | |||
975 | } | |||
976 | ||||
977 | template <class ELFO> | |||
978 | static const typename ELFO::Elf_Shdr * | |||
979 | findNotEmptySectionByAddress(const ELFO &Obj, StringRef FileName, | |||
980 | uint64_t Addr) { | |||
981 | for (const typename ELFO::Elf_Shdr &Shdr : cantFail(Obj.sections())) | |||
982 | if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) | |||
983 | return &Shdr; | |||
984 | return nullptr; | |||
985 | } | |||
986 | ||||
987 | const EnumEntry<unsigned> ElfClass[] = { | |||
988 | {"None", "none", ELF::ELFCLASSNONE}, | |||
989 | {"32-bit", "ELF32", ELF::ELFCLASS32}, | |||
990 | {"64-bit", "ELF64", ELF::ELFCLASS64}, | |||
991 | }; | |||
992 | ||||
993 | const EnumEntry<unsigned> ElfDataEncoding[] = { | |||
994 | {"None", "none", ELF::ELFDATANONE}, | |||
995 | {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, | |||
996 | {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, | |||
997 | }; | |||
998 | ||||
999 | const EnumEntry<unsigned> ElfObjectFileType[] = { | |||
1000 | {"None", "NONE (none)", ELF::ET_NONE}, | |||
1001 | {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, | |||
1002 | {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, | |||
1003 | {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, | |||
1004 | {"Core", "CORE (Core file)", ELF::ET_CORE}, | |||
1005 | }; | |||
1006 | ||||
1007 | const EnumEntry<unsigned> ElfOSABI[] = { | |||
1008 | {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, | |||
1009 | {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, | |||
1010 | {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, | |||
1011 | {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, | |||
1012 | {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, | |||
1013 | {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, | |||
1014 | {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, | |||
1015 | {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, | |||
1016 | {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, | |||
1017 | {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, | |||
1018 | {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, | |||
1019 | {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, | |||
1020 | {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, | |||
1021 | {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, | |||
1022 | {"AROS", "AROS", ELF::ELFOSABI_AROS}, | |||
1023 | {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, | |||
1024 | {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, | |||
1025 | {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} | |||
1026 | }; | |||
1027 | ||||
1028 | const EnumEntry<unsigned> AMDGPUElfOSABI[] = { | |||
1029 | {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA}, | |||
1030 | {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}, | |||
1031 | {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D} | |||
1032 | }; | |||
1033 | ||||
1034 | const EnumEntry<unsigned> ARMElfOSABI[] = { | |||
1035 | {"ARM", "ARM", ELF::ELFOSABI_ARM} | |||
1036 | }; | |||
1037 | ||||
1038 | const EnumEntry<unsigned> C6000ElfOSABI[] = { | |||
1039 | {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, | |||
1040 | {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX} | |||
1041 | }; | |||
1042 | ||||
1043 | const EnumEntry<unsigned> ElfMachineType[] = { | |||
1044 | ENUM_ENT(EM_NONE, "None"){ "EM_NONE", "None", ELF::EM_NONE }, | |||
1045 | ENUM_ENT(EM_M32, "WE32100"){ "EM_M32", "WE32100", ELF::EM_M32 }, | |||
1046 | ENUM_ENT(EM_SPARC, "Sparc"){ "EM_SPARC", "Sparc", ELF::EM_SPARC }, | |||
1047 | ENUM_ENT(EM_386, "Intel 80386"){ "EM_386", "Intel 80386", ELF::EM_386 }, | |||
1048 | ENUM_ENT(EM_68K, "MC68000"){ "EM_68K", "MC68000", ELF::EM_68K }, | |||
1049 | ENUM_ENT(EM_88K, "MC88000"){ "EM_88K", "MC88000", ELF::EM_88K }, | |||
1050 | ENUM_ENT(EM_IAMCU, "EM_IAMCU"){ "EM_IAMCU", "EM_IAMCU", ELF::EM_IAMCU }, | |||
1051 | ENUM_ENT(EM_860, "Intel 80860"){ "EM_860", "Intel 80860", ELF::EM_860 }, | |||
1052 | ENUM_ENT(EM_MIPS, "MIPS R3000"){ "EM_MIPS", "MIPS R3000", ELF::EM_MIPS }, | |||
1053 | ENUM_ENT(EM_S370, "IBM System/370"){ "EM_S370", "IBM System/370", ELF::EM_S370 }, | |||
1054 | ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"){ "EM_MIPS_RS3_LE", "MIPS R3000 little-endian", ELF::EM_MIPS_RS3_LE }, | |||
1055 | ENUM_ENT(EM_PARISC, "HPPA"){ "EM_PARISC", "HPPA", ELF::EM_PARISC }, | |||
1056 | ENUM_ENT(EM_VPP500, "Fujitsu VPP500"){ "EM_VPP500", "Fujitsu VPP500", ELF::EM_VPP500 }, | |||
1057 | ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"){ "EM_SPARC32PLUS", "Sparc v8+", ELF::EM_SPARC32PLUS }, | |||
1058 | ENUM_ENT(EM_960, "Intel 80960"){ "EM_960", "Intel 80960", ELF::EM_960 }, | |||
1059 | ENUM_ENT(EM_PPC, "PowerPC"){ "EM_PPC", "PowerPC", ELF::EM_PPC }, | |||
1060 | ENUM_ENT(EM_PPC64, "PowerPC64"){ "EM_PPC64", "PowerPC64", ELF::EM_PPC64 }, | |||
1061 | ENUM_ENT(EM_S390, "IBM S/390"){ "EM_S390", "IBM S/390", ELF::EM_S390 }, | |||
1062 | ENUM_ENT(EM_SPU, "SPU"){ "EM_SPU", "SPU", ELF::EM_SPU }, | |||
1063 | ENUM_ENT(EM_V800, "NEC V800 series"){ "EM_V800", "NEC V800 series", ELF::EM_V800 }, | |||
1064 | ENUM_ENT(EM_FR20, "Fujistsu FR20"){ "EM_FR20", "Fujistsu FR20", ELF::EM_FR20 }, | |||
1065 | ENUM_ENT(EM_RH32, "TRW RH-32"){ "EM_RH32", "TRW RH-32", ELF::EM_RH32 }, | |||
1066 | ENUM_ENT(EM_RCE, "Motorola RCE"){ "EM_RCE", "Motorola RCE", ELF::EM_RCE }, | |||
1067 | ENUM_ENT(EM_ARM, "ARM"){ "EM_ARM", "ARM", ELF::EM_ARM }, | |||
1068 | ENUM_ENT(EM_ALPHA, "EM_ALPHA"){ "EM_ALPHA", "EM_ALPHA", ELF::EM_ALPHA }, | |||
1069 | ENUM_ENT(EM_SH, "Hitachi SH"){ "EM_SH", "Hitachi SH", ELF::EM_SH }, | |||
1070 | ENUM_ENT(EM_SPARCV9, "Sparc v9"){ "EM_SPARCV9", "Sparc v9", ELF::EM_SPARCV9 }, | |||
1071 | ENUM_ENT(EM_TRICORE, "Siemens Tricore"){ "EM_TRICORE", "Siemens Tricore", ELF::EM_TRICORE }, | |||
1072 | ENUM_ENT(EM_ARC, "ARC"){ "EM_ARC", "ARC", ELF::EM_ARC }, | |||
1073 | ENUM_ENT(EM_H8_300, "Hitachi H8/300"){ "EM_H8_300", "Hitachi H8/300", ELF::EM_H8_300 }, | |||
1074 | ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"){ "EM_H8_300H", "Hitachi H8/300H", ELF::EM_H8_300H }, | |||
1075 | ENUM_ENT(EM_H8S, "Hitachi H8S"){ "EM_H8S", "Hitachi H8S", ELF::EM_H8S }, | |||
1076 | ENUM_ENT(EM_H8_500, "Hitachi H8/500"){ "EM_H8_500", "Hitachi H8/500", ELF::EM_H8_500 }, | |||
1077 | ENUM_ENT(EM_IA_64, "Intel IA-64"){ "EM_IA_64", "Intel IA-64", ELF::EM_IA_64 }, | |||
1078 | ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"){ "EM_MIPS_X", "Stanford MIPS-X", ELF::EM_MIPS_X }, | |||
1079 | ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"){ "EM_COLDFIRE", "Motorola Coldfire", ELF::EM_COLDFIRE }, | |||
1080 | ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"){ "EM_68HC12", "Motorola MC68HC12 Microcontroller", ELF::EM_68HC12 }, | |||
1081 | ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"){ "EM_MMA", "Fujitsu Multimedia Accelerator", ELF::EM_MMA }, | |||
1082 | ENUM_ENT(EM_PCP, "Siemens PCP"){ "EM_PCP", "Siemens PCP", ELF::EM_PCP }, | |||
1083 | ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"){ "EM_NCPU", "Sony nCPU embedded RISC processor", ELF::EM_NCPU }, | |||
1084 | ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"){ "EM_NDR1", "Denso NDR1 microprocesspr", ELF::EM_NDR1 }, | |||
1085 | ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"){ "EM_STARCORE", "Motorola Star*Core processor", ELF::EM_STARCORE }, | |||
1086 | ENUM_ENT(EM_ME16, "Toyota ME16 processor"){ "EM_ME16", "Toyota ME16 processor", ELF::EM_ME16 }, | |||
1087 | ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"){ "EM_ST100", "STMicroelectronics ST100 processor", ELF::EM_ST100 }, | |||
1088 | ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"){ "EM_TINYJ", "Advanced Logic Corp. TinyJ embedded processor" , ELF::EM_TINYJ }, | |||
1089 | ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"){ "EM_X86_64", "Advanced Micro Devices X86-64", ELF::EM_X86_64 }, | |||
1090 | ENUM_ENT(EM_PDSP, "Sony DSP processor"){ "EM_PDSP", "Sony DSP processor", ELF::EM_PDSP }, | |||
1091 | ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"){ "EM_PDP10", "Digital Equipment Corp. PDP-10", ELF::EM_PDP10 }, | |||
1092 | ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"){ "EM_PDP11", "Digital Equipment Corp. PDP-11", ELF::EM_PDP11 }, | |||
1093 | ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"){ "EM_FX66", "Siemens FX66 microcontroller", ELF::EM_FX66 }, | |||
1094 | ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"){ "EM_ST9PLUS", "STMicroelectronics ST9+ 8/16 bit microcontroller" , ELF::EM_ST9PLUS }, | |||
1095 | ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"){ "EM_ST7", "STMicroelectronics ST7 8-bit microcontroller", ELF ::EM_ST7 }, | |||
1096 | ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"){ "EM_68HC16", "Motorola MC68HC16 Microcontroller", ELF::EM_68HC16 }, | |||
1097 | ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"){ "EM_68HC11", "Motorola MC68HC11 Microcontroller", ELF::EM_68HC11 }, | |||
1098 | ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"){ "EM_68HC08", "Motorola MC68HC08 Microcontroller", ELF::EM_68HC08 }, | |||
1099 | ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"){ "EM_68HC05", "Motorola MC68HC05 Microcontroller", ELF::EM_68HC05 }, | |||
1100 | ENUM_ENT(EM_SVX, "Silicon Graphics SVx"){ "EM_SVX", "Silicon Graphics SVx", ELF::EM_SVX }, | |||
1101 | ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"){ "EM_ST19", "STMicroelectronics ST19 8-bit microcontroller", ELF::EM_ST19 }, | |||
1102 | ENUM_ENT(EM_VAX, "Digital VAX"){ "EM_VAX", "Digital VAX", ELF::EM_VAX }, | |||
1103 | ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"){ "EM_CRIS", "Axis Communications 32-bit embedded processor", ELF::EM_CRIS }, | |||
1104 | ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"){ "EM_JAVELIN", "Infineon Technologies 32-bit embedded cpu", ELF ::EM_JAVELIN }, | |||
1105 | ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"){ "EM_FIREPATH", "Element 14 64-bit DSP processor", ELF::EM_FIREPATH }, | |||
1106 | ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"){ "EM_ZSP", "LSI Logic's 16-bit DSP processor", ELF::EM_ZSP }, | |||
1107 | ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"){ "EM_MMIX", "Donald Knuth's educational 64-bit processor", ELF ::EM_MMIX }, | |||
1108 | ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"){ "EM_HUANY", "Harvard Universitys's machine-independent object format" , ELF::EM_HUANY }, | |||
1109 | ENUM_ENT(EM_PRISM, "Vitesse Prism"){ "EM_PRISM", "Vitesse Prism", ELF::EM_PRISM }, | |||
1110 | ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"){ "EM_AVR", "Atmel AVR 8-bit microcontroller", ELF::EM_AVR }, | |||
1111 | ENUM_ENT(EM_FR30, "Fujitsu FR30"){ "EM_FR30", "Fujitsu FR30", ELF::EM_FR30 }, | |||
1112 | ENUM_ENT(EM_D10V, "Mitsubishi D10V"){ "EM_D10V", "Mitsubishi D10V", ELF::EM_D10V }, | |||
1113 | ENUM_ENT(EM_D30V, "Mitsubishi D30V"){ "EM_D30V", "Mitsubishi D30V", ELF::EM_D30V }, | |||
1114 | ENUM_ENT(EM_V850, "NEC v850"){ "EM_V850", "NEC v850", ELF::EM_V850 }, | |||
1115 | ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"){ "EM_M32R", "Renesas M32R (formerly Mitsubishi M32r)", ELF:: EM_M32R }, | |||
1116 | ENUM_ENT(EM_MN10300, "Matsushita MN10300"){ "EM_MN10300", "Matsushita MN10300", ELF::EM_MN10300 }, | |||
1117 | ENUM_ENT(EM_MN10200, "Matsushita MN10200"){ "EM_MN10200", "Matsushita MN10200", ELF::EM_MN10200 }, | |||
1118 | ENUM_ENT(EM_PJ, "picoJava"){ "EM_PJ", "picoJava", ELF::EM_PJ }, | |||
1119 | ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"){ "EM_OPENRISC", "OpenRISC 32-bit embedded processor", ELF::EM_OPENRISC }, | |||
1120 | ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"){ "EM_ARC_COMPACT", "EM_ARC_COMPACT", ELF::EM_ARC_COMPACT }, | |||
1121 | ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"){ "EM_XTENSA", "Tensilica Xtensa Processor", ELF::EM_XTENSA }, | |||
1122 | ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"){ "EM_VIDEOCORE", "Alphamosaic VideoCore processor", ELF::EM_VIDEOCORE }, | |||
1123 | ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"){ "EM_TMM_GPP", "Thompson Multimedia General Purpose Processor" , ELF::EM_TMM_GPP }, | |||
1124 | ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"){ "EM_NS32K", "National Semiconductor 32000 series", ELF::EM_NS32K }, | |||
1125 | ENUM_ENT(EM_TPC, "Tenor Network TPC processor"){ "EM_TPC", "Tenor Network TPC processor", ELF::EM_TPC }, | |||
1126 | ENUM_ENT(EM_SNP1K, "EM_SNP1K"){ "EM_SNP1K", "EM_SNP1K", ELF::EM_SNP1K }, | |||
1127 | ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"){ "EM_ST200", "STMicroelectronics ST200 microcontroller", ELF ::EM_ST200 }, | |||
1128 | ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"){ "EM_IP2K", "Ubicom IP2xxx 8-bit microcontrollers", ELF::EM_IP2K }, | |||
1129 | ENUM_ENT(EM_MAX, "MAX Processor"){ "EM_MAX", "MAX Processor", ELF::EM_MAX }, | |||
1130 | ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"){ "EM_CR", "National Semiconductor CompactRISC", ELF::EM_CR }, | |||
1131 | ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"){ "EM_F2MC16", "Fujitsu F2MC16", ELF::EM_F2MC16 }, | |||
1132 | ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"){ "EM_MSP430", "Texas Instruments msp430 microcontroller", ELF ::EM_MSP430 }, | |||
1133 | ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"){ "EM_BLACKFIN", "Analog Devices Blackfin", ELF::EM_BLACKFIN }, | |||
1134 | ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"){ "EM_SE_C33", "S1C33 Family of Seiko Epson processors", ELF:: EM_SE_C33 }, | |||
1135 | ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"){ "EM_SEP", "Sharp embedded microprocessor", ELF::EM_SEP }, | |||
1136 | ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"){ "EM_ARCA", "Arca RISC microprocessor", ELF::EM_ARCA }, | |||
1137 | ENUM_ENT(EM_UNICORE, "Unicore"){ "EM_UNICORE", "Unicore", ELF::EM_UNICORE }, | |||
1138 | ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"){ "EM_EXCESS", "eXcess 16/32/64-bit configurable embedded CPU" , ELF::EM_EXCESS }, | |||
1139 | ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"){ "EM_DXP", "Icera Semiconductor Inc. Deep Execution Processor" , ELF::EM_DXP }, | |||
1140 | ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"){ "EM_ALTERA_NIOS2", "Altera Nios", ELF::EM_ALTERA_NIOS2 }, | |||
1141 | ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"){ "EM_CRX", "National Semiconductor CRX microprocessor", ELF:: EM_CRX }, | |||
1142 | ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"){ "EM_XGATE", "Motorola XGATE embedded processor", ELF::EM_XGATE }, | |||
1143 | ENUM_ENT(EM_C166, "Infineon Technologies xc16x"){ "EM_C166", "Infineon Technologies xc16x", ELF::EM_C166 }, | |||
1144 | ENUM_ENT(EM_M16C, "Renesas M16C"){ "EM_M16C", "Renesas M16C", ELF::EM_M16C }, | |||
1145 | ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"){ "EM_DSPIC30F", "Microchip Technology dsPIC30F Digital Signal Controller" , ELF::EM_DSPIC30F }, | |||
1146 | ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"){ "EM_CE", "Freescale Communication Engine RISC core", ELF::EM_CE }, | |||
1147 | ENUM_ENT(EM_M32C, "Renesas M32C"){ "EM_M32C", "Renesas M32C", ELF::EM_M32C }, | |||
1148 | ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"){ "EM_TSK3000", "Altium TSK3000 core", ELF::EM_TSK3000 }, | |||
1149 | ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"){ "EM_RS08", "Freescale RS08 embedded processor", ELF::EM_RS08 }, | |||
1150 | ENUM_ENT(EM_SHARC, "EM_SHARC"){ "EM_SHARC", "EM_SHARC", ELF::EM_SHARC }, | |||
1151 | ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"){ "EM_ECOG2", "Cyan Technology eCOG2 microprocessor", ELF::EM_ECOG2 }, | |||
1152 | ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"){ "EM_SCORE7", "SUNPLUS S+Core", ELF::EM_SCORE7 }, | |||
1153 | ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"){ "EM_DSP24", "New Japan Radio (NJR) 24-bit DSP Processor", ELF ::EM_DSP24 }, | |||
1154 | ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"){ "EM_VIDEOCORE3", "Broadcom VideoCore III processor", ELF::EM_VIDEOCORE3 }, | |||
1155 | ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"){ "EM_LATTICEMICO32", "Lattice Mico32", ELF::EM_LATTICEMICO32 }, | |||
1156 | ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"){ "EM_SE_C17", "Seiko Epson C17 family", ELF::EM_SE_C17 }, | |||
1157 | ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"){ "EM_TI_C6000", "Texas Instruments TMS320C6000 DSP family", ELF ::EM_TI_C6000 }, | |||
1158 | ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"){ "EM_TI_C2000", "Texas Instruments TMS320C2000 DSP family", ELF ::EM_TI_C2000 }, | |||
1159 | ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"){ "EM_TI_C5500", "Texas Instruments TMS320C55x DSP family", ELF ::EM_TI_C5500 }, | |||
1160 | ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"){ "EM_MMDSP_PLUS", "STMicroelectronics 64bit VLIW Data Signal Processor" , ELF::EM_MMDSP_PLUS }, | |||
1161 | ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"){ "EM_CYPRESS_M8C", "Cypress M8C microprocessor", ELF::EM_CYPRESS_M8C }, | |||
1162 | ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"){ "EM_R32C", "Renesas R32C series microprocessors", ELF::EM_R32C }, | |||
1163 | ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"){ "EM_TRIMEDIA", "NXP Semiconductors TriMedia architecture family" , ELF::EM_TRIMEDIA }, | |||
1164 | ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"){ "EM_HEXAGON", "Qualcomm Hexagon", ELF::EM_HEXAGON }, | |||
1165 | ENUM_ENT(EM_8051, "Intel 8051 and variants"){ "EM_8051", "Intel 8051 and variants", ELF::EM_8051 }, | |||
1166 | ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"){ "EM_STXP7X", "STMicroelectronics STxP7x family", ELF::EM_STXP7X }, | |||
1167 | ENUM_ENT(EM_NDS32, "Andes Technology compact code size embedded RISC processor family"){ "EM_NDS32", "Andes Technology compact code size embedded RISC processor family" , ELF::EM_NDS32 }, | |||
1168 | ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"){ "EM_ECOG1", "Cyan Technology eCOG1 microprocessor", ELF::EM_ECOG1 }, | |||
1169 | // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has | |||
1170 | // an identical number to EM_ECOG1. | |||
1171 | ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"){ "EM_ECOG1X", "Cyan Technology eCOG1X family", ELF::EM_ECOG1X }, | |||
1172 | ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"){ "EM_MAXQ30", "Dallas Semiconductor MAXQ30 Core microcontrollers" , ELF::EM_MAXQ30 }, | |||
1173 | ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"){ "EM_XIMO16", "New Japan Radio (NJR) 16-bit DSP Processor", ELF ::EM_XIMO16 }, | |||
1174 | ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"){ "EM_MANIK", "M2000 Reconfigurable RISC Microprocessor", ELF ::EM_MANIK }, | |||
1175 | ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"){ "EM_CRAYNV2", "Cray Inc. NV2 vector architecture", ELF::EM_CRAYNV2 }, | |||
1176 | ENUM_ENT(EM_RX, "Renesas RX"){ "EM_RX", "Renesas RX", ELF::EM_RX }, | |||
1177 | ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"){ "EM_METAG", "Imagination Technologies Meta processor architecture" , ELF::EM_METAG }, | |||
1178 | ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"){ "EM_MCST_ELBRUS", "MCST Elbrus general purpose hardware architecture" , ELF::EM_MCST_ELBRUS }, | |||
1179 | ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"){ "EM_ECOG16", "Cyan Technology eCOG16 family", ELF::EM_ECOG16 }, | |||
1180 | ENUM_ENT(EM_CR16, "National Semiconductor CompactRISC 16-bit processor"){ "EM_CR16", "National Semiconductor CompactRISC 16-bit processor" , ELF::EM_CR16 }, | |||
1181 | ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"){ "EM_ETPU", "Freescale Extended Time Processing Unit", ELF:: EM_ETPU }, | |||
1182 | ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"){ "EM_SLE9X", "Infineon Technologies SLE9X core", ELF::EM_SLE9X }, | |||
1183 | ENUM_ENT(EM_L10M, "EM_L10M"){ "EM_L10M", "EM_L10M", ELF::EM_L10M }, | |||
1184 | ENUM_ENT(EM_K10M, "EM_K10M"){ "EM_K10M", "EM_K10M", ELF::EM_K10M }, | |||
1185 | ENUM_ENT(EM_AARCH64, "AArch64"){ "EM_AARCH64", "AArch64", ELF::EM_AARCH64 }, | |||
1186 | ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"){ "EM_AVR32", "Atmel Corporation 32-bit microprocessor family" , ELF::EM_AVR32 }, | |||
1187 | ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"){ "EM_STM8", "STMicroeletronics STM8 8-bit microcontroller", ELF ::EM_STM8 }, | |||
1188 | ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"){ "EM_TILE64", "Tilera TILE64 multicore architecture family", ELF::EM_TILE64 }, | |||
1189 | ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"){ "EM_TILEPRO", "Tilera TILEPro multicore architecture family" , ELF::EM_TILEPRO }, | |||
1190 | ENUM_ENT(EM_MICROBLAZE, "Xilinx MicroBlaze 32-bit RISC soft processor core"){ "EM_MICROBLAZE", "Xilinx MicroBlaze 32-bit RISC soft processor core" , ELF::EM_MICROBLAZE }, | |||
1191 | ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"){ "EM_CUDA", "NVIDIA CUDA architecture", ELF::EM_CUDA }, | |||
1192 | ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"){ "EM_TILEGX", "Tilera TILE-Gx multicore architecture family" , ELF::EM_TILEGX }, | |||
1193 | ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"){ "EM_CLOUDSHIELD", "EM_CLOUDSHIELD", ELF::EM_CLOUDSHIELD }, | |||
1194 | ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"){ "EM_COREA_1ST", "EM_COREA_1ST", ELF::EM_COREA_1ST }, | |||
1195 | ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"){ "EM_COREA_2ND", "EM_COREA_2ND", ELF::EM_COREA_2ND }, | |||
1196 | ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"){ "EM_ARC_COMPACT2", "EM_ARC_COMPACT2", ELF::EM_ARC_COMPACT2 }, | |||
1197 | ENUM_ENT(EM_OPEN8, "EM_OPEN8"){ "EM_OPEN8", "EM_OPEN8", ELF::EM_OPEN8 }, | |||
1198 | ENUM_ENT(EM_RL78, "Renesas RL78"){ "EM_RL78", "Renesas RL78", ELF::EM_RL78 }, | |||
1199 | ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"){ "EM_VIDEOCORE5", "Broadcom VideoCore V processor", ELF::EM_VIDEOCORE5 }, | |||
1200 | ENUM_ENT(EM_78KOR, "EM_78KOR"){ "EM_78KOR", "EM_78KOR", ELF::EM_78KOR }, | |||
1201 | ENUM_ENT(EM_56800EX, "EM_56800EX"){ "EM_56800EX", "EM_56800EX", ELF::EM_56800EX }, | |||
1202 | ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"){ "EM_AMDGPU", "EM_AMDGPU", ELF::EM_AMDGPU }, | |||
1203 | ENUM_ENT(EM_RISCV, "RISC-V"){ "EM_RISCV", "RISC-V", ELF::EM_RISCV }, | |||
1204 | ENUM_ENT(EM_LANAI, "EM_LANAI"){ "EM_LANAI", "EM_LANAI", ELF::EM_LANAI }, | |||
1205 | ENUM_ENT(EM_BPF, "EM_BPF"){ "EM_BPF", "EM_BPF", ELF::EM_BPF }, | |||
1206 | ENUM_ENT(EM_VE, "NEC SX-Aurora Vector Engine"){ "EM_VE", "NEC SX-Aurora Vector Engine", ELF::EM_VE }, | |||
1207 | ENUM_ENT(EM_LOONGARCH, "LoongArch"){ "EM_LOONGARCH", "LoongArch", ELF::EM_LOONGARCH }, | |||
1208 | }; | |||
1209 | ||||
1210 | const EnumEntry<unsigned> ElfSymbolBindings[] = { | |||
1211 | {"Local", "LOCAL", ELF::STB_LOCAL}, | |||
1212 | {"Global", "GLOBAL", ELF::STB_GLOBAL}, | |||
1213 | {"Weak", "WEAK", ELF::STB_WEAK}, | |||
1214 | {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; | |||
1215 | ||||
1216 | const EnumEntry<unsigned> ElfSymbolVisibilities[] = { | |||
1217 | {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, | |||
1218 | {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, | |||
1219 | {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, | |||
1220 | {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; | |||
1221 | ||||
1222 | const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { | |||
1223 | { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL } | |||
1224 | }; | |||
1225 | ||||
1226 | static const char *getGroupType(uint32_t Flag) { | |||
1227 | if (Flag & ELF::GRP_COMDAT) | |||
1228 | return "COMDAT"; | |||
1229 | else | |||
1230 | return "(unknown)"; | |||
1231 | } | |||
1232 | ||||
1233 | const EnumEntry<unsigned> ElfSectionFlags[] = { | |||
1234 | ENUM_ENT(SHF_WRITE, "W"){ "SHF_WRITE", "W", ELF::SHF_WRITE }, | |||
1235 | ENUM_ENT(SHF_ALLOC, "A"){ "SHF_ALLOC", "A", ELF::SHF_ALLOC }, | |||
1236 | ENUM_ENT(SHF_EXECINSTR, "X"){ "SHF_EXECINSTR", "X", ELF::SHF_EXECINSTR }, | |||
1237 | ENUM_ENT(SHF_MERGE, "M"){ "SHF_MERGE", "M", ELF::SHF_MERGE }, | |||
1238 | ENUM_ENT(SHF_STRINGS, "S"){ "SHF_STRINGS", "S", ELF::SHF_STRINGS }, | |||
1239 | ENUM_ENT(SHF_INFO_LINK, "I"){ "SHF_INFO_LINK", "I", ELF::SHF_INFO_LINK }, | |||
1240 | ENUM_ENT(SHF_LINK_ORDER, "L"){ "SHF_LINK_ORDER", "L", ELF::SHF_LINK_ORDER }, | |||
1241 | ENUM_ENT(SHF_OS_NONCONFORMING, "O"){ "SHF_OS_NONCONFORMING", "O", ELF::SHF_OS_NONCONFORMING }, | |||
1242 | ENUM_ENT(SHF_GROUP, "G"){ "SHF_GROUP", "G", ELF::SHF_GROUP }, | |||
1243 | ENUM_ENT(SHF_TLS, "T"){ "SHF_TLS", "T", ELF::SHF_TLS }, | |||
1244 | ENUM_ENT(SHF_COMPRESSED, "C"){ "SHF_COMPRESSED", "C", ELF::SHF_COMPRESSED }, | |||
1245 | ENUM_ENT(SHF_EXCLUDE, "E"){ "SHF_EXCLUDE", "E", ELF::SHF_EXCLUDE }, | |||
1246 | }; | |||
1247 | ||||
1248 | const EnumEntry<unsigned> ElfGNUSectionFlags[] = { | |||
1249 | ENUM_ENT(SHF_GNU_RETAIN, "R"){ "SHF_GNU_RETAIN", "R", ELF::SHF_GNU_RETAIN } | |||
1250 | }; | |||
1251 | ||||
1252 | const EnumEntry<unsigned> ElfSolarisSectionFlags[] = { | |||
1253 | ENUM_ENT(SHF_SUNW_NODISCARD, "R"){ "SHF_SUNW_NODISCARD", "R", ELF::SHF_SUNW_NODISCARD } | |||
1254 | }; | |||
1255 | ||||
1256 | const EnumEntry<unsigned> ElfXCoreSectionFlags[] = { | |||
1257 | ENUM_ENT(XCORE_SHF_CP_SECTION, ""){ "XCORE_SHF_CP_SECTION", "", ELF::XCORE_SHF_CP_SECTION }, | |||
1258 | ENUM_ENT(XCORE_SHF_DP_SECTION, ""){ "XCORE_SHF_DP_SECTION", "", ELF::XCORE_SHF_DP_SECTION } | |||
1259 | }; | |||
1260 | ||||
1261 | const EnumEntry<unsigned> ElfARMSectionFlags[] = { | |||
1262 | ENUM_ENT(SHF_ARM_PURECODE, "y"){ "SHF_ARM_PURECODE", "y", ELF::SHF_ARM_PURECODE } | |||
1263 | }; | |||
1264 | ||||
1265 | const EnumEntry<unsigned> ElfHexagonSectionFlags[] = { | |||
1266 | ENUM_ENT(SHF_HEX_GPREL, ""){ "SHF_HEX_GPREL", "", ELF::SHF_HEX_GPREL } | |||
1267 | }; | |||
1268 | ||||
1269 | const EnumEntry<unsigned> ElfMipsSectionFlags[] = { | |||
1270 | ENUM_ENT(SHF_MIPS_NODUPES, ""){ "SHF_MIPS_NODUPES", "", ELF::SHF_MIPS_NODUPES }, | |||
1271 | ENUM_ENT(SHF_MIPS_NAMES, ""){ "SHF_MIPS_NAMES", "", ELF::SHF_MIPS_NAMES }, | |||
1272 | ENUM_ENT(SHF_MIPS_LOCAL, ""){ "SHF_MIPS_LOCAL", "", ELF::SHF_MIPS_LOCAL }, | |||
1273 | ENUM_ENT(SHF_MIPS_NOSTRIP, ""){ "SHF_MIPS_NOSTRIP", "", ELF::SHF_MIPS_NOSTRIP }, | |||
1274 | ENUM_ENT(SHF_MIPS_GPREL, ""){ "SHF_MIPS_GPREL", "", ELF::SHF_MIPS_GPREL }, | |||
1275 | ENUM_ENT(SHF_MIPS_MERGE, ""){ "SHF_MIPS_MERGE", "", ELF::SHF_MIPS_MERGE }, | |||
1276 | ENUM_ENT(SHF_MIPS_ADDR, ""){ "SHF_MIPS_ADDR", "", ELF::SHF_MIPS_ADDR }, | |||
1277 | ENUM_ENT(SHF_MIPS_STRING, ""){ "SHF_MIPS_STRING", "", ELF::SHF_MIPS_STRING } | |||
1278 | }; | |||
1279 | ||||
1280 | const EnumEntry<unsigned> ElfX86_64SectionFlags[] = { | |||
1281 | ENUM_ENT(SHF_X86_64_LARGE, "l"){ "SHF_X86_64_LARGE", "l", ELF::SHF_X86_64_LARGE } | |||
1282 | }; | |||
1283 | ||||
1284 | static std::vector<EnumEntry<unsigned>> | |||
1285 | getSectionFlagsForTarget(unsigned EOSAbi, unsigned EMachine) { | |||
1286 | std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags), | |||
1287 | std::end(ElfSectionFlags)); | |||
1288 | switch (EOSAbi) { | |||
1289 | case ELFOSABI_SOLARIS: | |||
1290 | Ret.insert(Ret.end(), std::begin(ElfSolarisSectionFlags), | |||
1291 | std::end(ElfSolarisSectionFlags)); | |||
1292 | break; | |||
1293 | default: | |||
1294 | Ret.insert(Ret.end(), std::begin(ElfGNUSectionFlags), | |||
1295 | std::end(ElfGNUSectionFlags)); | |||
1296 | break; | |||
1297 | } | |||
1298 | switch (EMachine) { | |||
1299 | case EM_ARM: | |||
1300 | Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags), | |||
1301 | std::end(ElfARMSectionFlags)); | |||
1302 | break; | |||
1303 | case EM_HEXAGON: | |||
1304 | Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags), | |||
1305 | std::end(ElfHexagonSectionFlags)); | |||
1306 | break; | |||
1307 | case EM_MIPS: | |||
1308 | Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags), | |||
1309 | std::end(ElfMipsSectionFlags)); | |||
1310 | break; | |||
1311 | case EM_X86_64: | |||
1312 | Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags), | |||
1313 | std::end(ElfX86_64SectionFlags)); | |||
1314 | break; | |||
1315 | case EM_XCORE: | |||
1316 | Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags), | |||
1317 | std::end(ElfXCoreSectionFlags)); | |||
1318 | break; | |||
1319 | default: | |||
1320 | break; | |||
1321 | } | |||
1322 | return Ret; | |||
1323 | } | |||
1324 | ||||
1325 | static std::string getGNUFlags(unsigned EOSAbi, unsigned EMachine, | |||
1326 | uint64_t Flags) { | |||
1327 | // Here we are trying to build the flags string in the same way as GNU does. | |||
1328 | // It is not that straightforward. Imagine we have sh_flags == 0x90000000. | |||
1329 | // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000. | |||
1330 | // GNU readelf will not print "E" or "Ep" in this case, but will print just | |||
1331 | // "p". It only will print "E" when no other processor flag is set. | |||
1332 | std::string Str; | |||
1333 | bool HasUnknownFlag = false; | |||
1334 | bool HasOSFlag = false; | |||
1335 | bool HasProcFlag = false; | |||
1336 | std::vector<EnumEntry<unsigned>> FlagsList = | |||
1337 | getSectionFlagsForTarget(EOSAbi, EMachine); | |||
1338 | while (Flags) { | |||
1339 | // Take the least significant bit as a flag. | |||
1340 | uint64_t Flag = Flags & -Flags; | |||
1341 | Flags -= Flag; | |||
1342 | ||||
1343 | // Find the flag in the known flags list. | |||
1344 | auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) { | |||
1345 | // Flags with empty names are not printed in GNU style output. | |||
1346 | return E.Value == Flag && !E.AltName.empty(); | |||
1347 | }); | |||
1348 | if (I != FlagsList.end()) { | |||
1349 | Str += I->AltName; | |||
1350 | continue; | |||
1351 | } | |||
1352 | ||||
1353 | // If we did not find a matching regular flag, then we deal with an OS | |||
1354 | // specific flag, processor specific flag or an unknown flag. | |||
1355 | if (Flag & ELF::SHF_MASKOS) { | |||
1356 | HasOSFlag = true; | |||
1357 | Flags &= ~ELF::SHF_MASKOS; | |||
1358 | } else if (Flag & ELF::SHF_MASKPROC) { | |||
1359 | HasProcFlag = true; | |||
1360 | // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE | |||
1361 | // bit if set so that it doesn't also get printed. | |||
1362 | Flags &= ~ELF::SHF_MASKPROC; | |||
1363 | } else { | |||
1364 | HasUnknownFlag = true; | |||
1365 | } | |||
1366 | } | |||
1367 | ||||
1368 | // "o", "p" and "x" are printed last. | |||
1369 | if (HasOSFlag) | |||
1370 | Str += "o"; | |||
1371 | if (HasProcFlag) | |||
1372 | Str += "p"; | |||
1373 | if (HasUnknownFlag) | |||
1374 | Str += "x"; | |||
1375 | return Str; | |||
1376 | } | |||
1377 | ||||
1378 | static StringRef segmentTypeToString(unsigned Arch, unsigned Type) { | |||
1379 | // Check potentially overlapped processor-specific program header type. | |||
1380 | switch (Arch) { | |||
1381 | case ELF::EM_ARM: | |||
1382 | switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX)case ELF::PT_ARM_EXIDX: return "PT_ARM_EXIDX";; } | |||
1383 | break; | |||
1384 | case ELF::EM_MIPS: | |||
1385 | case ELF::EM_MIPS_RS3_LE: | |||
1386 | switch (Type) { | |||
1387 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO)case ELF::PT_MIPS_REGINFO: return "PT_MIPS_REGINFO";; | |||
1388 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC)case ELF::PT_MIPS_RTPROC: return "PT_MIPS_RTPROC";; | |||
1389 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS)case ELF::PT_MIPS_OPTIONS: return "PT_MIPS_OPTIONS";; | |||
1390 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS)case ELF::PT_MIPS_ABIFLAGS: return "PT_MIPS_ABIFLAGS";; | |||
1391 | } | |||
1392 | break; | |||
1393 | } | |||
1394 | ||||
1395 | switch (Type) { | |||
1396 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL)case ELF::PT_NULL: return "PT_NULL";; | |||
1397 | LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD)case ELF::PT_LOAD: return "PT_LOAD";; | |||
1398 | LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC)case ELF::PT_DYNAMIC: return "PT_DYNAMIC";; | |||
1399 | LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP)case ELF::PT_INTERP: return "PT_INTERP";; | |||
1400 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE)case ELF::PT_NOTE: return "PT_NOTE";; | |||
1401 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB)case ELF::PT_SHLIB: return "PT_SHLIB";; | |||
1402 | LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR)case ELF::PT_PHDR: return "PT_PHDR";; | |||
1403 | LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS)case ELF::PT_TLS: return "PT_TLS";; | |||
1404 | ||||
1405 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME)case ELF::PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME";; | |||
1406 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND)case ELF::PT_SUNW_UNWIND: return "PT_SUNW_UNWIND";; | |||
1407 | ||||
1408 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK)case ELF::PT_GNU_STACK: return "PT_GNU_STACK";; | |||
1409 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO)case ELF::PT_GNU_RELRO: return "PT_GNU_RELRO";; | |||
1410 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_PROPERTY)case ELF::PT_GNU_PROPERTY: return "PT_GNU_PROPERTY";; | |||
1411 | ||||
1412 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE)case ELF::PT_OPENBSD_RANDOMIZE: return "PT_OPENBSD_RANDOMIZE" ;; | |||
1413 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED)case ELF::PT_OPENBSD_WXNEEDED: return "PT_OPENBSD_WXNEEDED";; | |||
1414 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA)case ELF::PT_OPENBSD_BOOTDATA: return "PT_OPENBSD_BOOTDATA";; | |||
1415 | default: | |||
1416 | return ""; | |||
1417 | } | |||
1418 | } | |||
1419 | ||||
1420 | static std::string getGNUPtType(unsigned Arch, unsigned Type) { | |||
1421 | StringRef Seg = segmentTypeToString(Arch, Type); | |||
1422 | if (Seg.empty()) | |||
1423 | return std::string("<unknown>: ") + to_string(format_hex(Type, 1)); | |||
1424 | ||||
1425 | // E.g. "PT_ARM_EXIDX" -> "EXIDX". | |||
1426 | if (Seg.startswith("PT_ARM_")) | |||
1427 | return Seg.drop_front(7).str(); | |||
1428 | ||||
1429 | // E.g. "PT_MIPS_REGINFO" -> "REGINFO". | |||
1430 | if (Seg.startswith("PT_MIPS_")) | |||
1431 | return Seg.drop_front(8).str(); | |||
1432 | ||||
1433 | // E.g. "PT_LOAD" -> "LOAD". | |||
1434 | assert(Seg.startswith("PT_"))(static_cast <bool> (Seg.startswith("PT_")) ? void (0) : __assert_fail ("Seg.startswith(\"PT_\")", "llvm/tools/llvm-readobj/ELFDumper.cpp" , 1434, __extension__ __PRETTY_FUNCTION__)); | |||
1435 | return Seg.drop_front(3).str(); | |||
1436 | } | |||
1437 | ||||
1438 | const EnumEntry<unsigned> ElfSegmentFlags[] = { | |||
1439 | LLVM_READOBJ_ENUM_ENT(ELF, PF_X){ "PF_X", ELF::PF_X }, | |||
1440 | LLVM_READOBJ_ENUM_ENT(ELF, PF_W){ "PF_W", ELF::PF_W }, | |||
1441 | LLVM_READOBJ_ENUM_ENT(ELF, PF_R){ "PF_R", ELF::PF_R } | |||
1442 | }; | |||
1443 | ||||
1444 | const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { | |||
1445 | ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"){ "EF_MIPS_NOREORDER", "noreorder", ELF::EF_MIPS_NOREORDER }, | |||
1446 | ENUM_ENT(EF_MIPS_PIC, "pic"){ "EF_MIPS_PIC", "pic", ELF::EF_MIPS_PIC }, | |||
1447 | ENUM_ENT(EF_MIPS_CPIC, "cpic"){ "EF_MIPS_CPIC", "cpic", ELF::EF_MIPS_CPIC }, | |||
1448 | ENUM_ENT(EF_MIPS_ABI2, "abi2"){ "EF_MIPS_ABI2", "abi2", ELF::EF_MIPS_ABI2 }, | |||
1449 | ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"){ "EF_MIPS_32BITMODE", "32bitmode", ELF::EF_MIPS_32BITMODE }, | |||
1450 | ENUM_ENT(EF_MIPS_FP64, "fp64"){ "EF_MIPS_FP64", "fp64", ELF::EF_MIPS_FP64 }, | |||
1451 | ENUM_ENT(EF_MIPS_NAN2008, "nan2008"){ "EF_MIPS_NAN2008", "nan2008", ELF::EF_MIPS_NAN2008 }, | |||
1452 | ENUM_ENT(EF_MIPS_ABI_O32, "o32"){ "EF_MIPS_ABI_O32", "o32", ELF::EF_MIPS_ABI_O32 }, | |||
1453 | ENUM_ENT(EF_MIPS_ABI_O64, "o64"){ "EF_MIPS_ABI_O64", "o64", ELF::EF_MIPS_ABI_O64 }, | |||
1454 | ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"){ "EF_MIPS_ABI_EABI32", "eabi32", ELF::EF_MIPS_ABI_EABI32 }, | |||
1455 | ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"){ "EF_MIPS_ABI_EABI64", "eabi64", ELF::EF_MIPS_ABI_EABI64 }, | |||
1456 | ENUM_ENT(EF_MIPS_MACH_3900, "3900"){ "EF_MIPS_MACH_3900", "3900", ELF::EF_MIPS_MACH_3900 }, | |||
1457 | ENUM_ENT(EF_MIPS_MACH_4010, "4010"){ "EF_MIPS_MACH_4010", "4010", ELF::EF_MIPS_MACH_4010 }, | |||
1458 | ENUM_ENT(EF_MIPS_MACH_4100, "4100"){ "EF_MIPS_MACH_4100", "4100", ELF::EF_MIPS_MACH_4100 }, | |||
1459 | ENUM_ENT(EF_MIPS_MACH_4650, "4650"){ "EF_MIPS_MACH_4650", "4650", ELF::EF_MIPS_MACH_4650 }, | |||
1460 | ENUM_ENT(EF_MIPS_MACH_4120, "4120"){ "EF_MIPS_MACH_4120", "4120", ELF::EF_MIPS_MACH_4120 }, | |||
1461 | ENUM_ENT(EF_MIPS_MACH_4111, "4111"){ "EF_MIPS_MACH_4111", "4111", ELF::EF_MIPS_MACH_4111 }, | |||
1462 | ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"){ "EF_MIPS_MACH_SB1", "sb1", ELF::EF_MIPS_MACH_SB1 }, | |||
1463 | ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"){ "EF_MIPS_MACH_OCTEON", "octeon", ELF::EF_MIPS_MACH_OCTEON }, | |||
1464 | ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"){ "EF_MIPS_MACH_XLR", "xlr", ELF::EF_MIPS_MACH_XLR }, | |||
1465 | ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"){ "EF_MIPS_MACH_OCTEON2", "octeon2", ELF::EF_MIPS_MACH_OCTEON2 }, | |||
1466 | ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"){ "EF_MIPS_MACH_OCTEON3", "octeon3", ELF::EF_MIPS_MACH_OCTEON3 }, | |||
1467 | ENUM_ENT(EF_MIPS_MACH_5400, "5400"){ "EF_MIPS_MACH_5400", "5400", ELF::EF_MIPS_MACH_5400 }, | |||
1468 | ENUM_ENT(EF_MIPS_MACH_5900, "5900"){ "EF_MIPS_MACH_5900", "5900", ELF::EF_MIPS_MACH_5900 }, | |||
1469 | ENUM_ENT(EF_MIPS_MACH_5500, "5500"){ "EF_MIPS_MACH_5500", "5500", ELF::EF_MIPS_MACH_5500 }, | |||
1470 | ENUM_ENT(EF_MIPS_MACH_9000, "9000"){ "EF_MIPS_MACH_9000", "9000", ELF::EF_MIPS_MACH_9000 }, | |||
1471 | ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"){ "EF_MIPS_MACH_LS2E", "loongson-2e", ELF::EF_MIPS_MACH_LS2E }, | |||
1472 | ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"){ "EF_MIPS_MACH_LS2F", "loongson-2f", ELF::EF_MIPS_MACH_LS2F }, | |||
1473 | ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"){ "EF_MIPS_MACH_LS3A", "loongson-3a", ELF::EF_MIPS_MACH_LS3A }, | |||
1474 | ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"){ "EF_MIPS_MICROMIPS", "micromips", ELF::EF_MIPS_MICROMIPS }, | |||
1475 | ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"){ "EF_MIPS_ARCH_ASE_M16", "mips16", ELF::EF_MIPS_ARCH_ASE_M16 }, | |||
1476 | ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"){ "EF_MIPS_ARCH_ASE_MDMX", "mdmx", ELF::EF_MIPS_ARCH_ASE_MDMX }, | |||
1477 | ENUM_ENT(EF_MIPS_ARCH_1, "mips1"){ "EF_MIPS_ARCH_1", "mips1", ELF::EF_MIPS_ARCH_1 }, | |||
1478 | ENUM_ENT(EF_MIPS_ARCH_2, "mips2"){ "EF_MIPS_ARCH_2", "mips2", ELF::EF_MIPS_ARCH_2 }, | |||
1479 | ENUM_ENT(EF_MIPS_ARCH_3, "mips3"){ "EF_MIPS_ARCH_3", "mips3", ELF::EF_MIPS_ARCH_3 }, | |||
1480 | ENUM_ENT(EF_MIPS_ARCH_4, "mips4"){ "EF_MIPS_ARCH_4", "mips4", ELF::EF_MIPS_ARCH_4 }, | |||
1481 | ENUM_ENT(EF_MIPS_ARCH_5, "mips5"){ "EF_MIPS_ARCH_5", "mips5", ELF::EF_MIPS_ARCH_5 }, | |||
1482 | ENUM_ENT(EF_MIPS_ARCH_32, "mips32"){ "EF_MIPS_ARCH_32", "mips32", ELF::EF_MIPS_ARCH_32 }, | |||
1483 | ENUM_ENT(EF_MIPS_ARCH_64, "mips64"){ "EF_MIPS_ARCH_64", "mips64", ELF::EF_MIPS_ARCH_64 }, | |||
1484 | ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"){ "EF_MIPS_ARCH_32R2", "mips32r2", ELF::EF_MIPS_ARCH_32R2 }, | |||
1485 | ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"){ "EF_MIPS_ARCH_64R2", "mips64r2", ELF::EF_MIPS_ARCH_64R2 }, | |||
1486 | ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"){ "EF_MIPS_ARCH_32R6", "mips32r6", ELF::EF_MIPS_ARCH_32R6 }, | |||
1487 | ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6"){ "EF_MIPS_ARCH_64R6", "mips64r6", ELF::EF_MIPS_ARCH_64R6 } | |||
1488 | }; | |||
1489 | ||||
1490 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion3[] = { | |||
1491 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1492 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1493 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1494 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1495 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1496 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1497 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1498 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1499 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1500 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1501 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1502 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1503 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1504 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1505 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1506 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1507 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1508 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1509 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1510 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1511 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1512 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1513 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1514 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1515 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1516 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1517 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1518 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1519 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1520 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1521 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1522 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1523 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1524 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1525 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1526 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1527 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1528 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1529 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1530 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1531 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1532 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1533 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1534 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1535 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1536 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1537 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1538 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1539 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1540 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1541 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1542 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_V3){ "EF_AMDGPU_FEATURE_XNACK_V3", ELF::EF_AMDGPU_FEATURE_XNACK_V3 }, | |||
1543 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_V3){ "EF_AMDGPU_FEATURE_SRAMECC_V3", ELF::EF_AMDGPU_FEATURE_SRAMECC_V3 } | |||
1544 | }; | |||
1545 | ||||
1546 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion4[] = { | |||
1547 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1548 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1549 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1550 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1551 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1552 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1553 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1554 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1555 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1556 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1557 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1558 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1559 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1560 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1561 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1562 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1563 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1564 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1565 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1566 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1567 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1568 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1569 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1570 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1571 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1572 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1573 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1574 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1575 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1576 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1577 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1578 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1579 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1580 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1581 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1582 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1583 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1584 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1585 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1586 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1587 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1588 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1589 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1590 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1591 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1592 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1593 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1594 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1595 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1596 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1597 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1598 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ANY_V4){ "EF_AMDGPU_FEATURE_XNACK_ANY_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4 }, | |||
1599 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_OFF_V4){ "EF_AMDGPU_FEATURE_XNACK_OFF_V4", ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4 }, | |||
1600 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ON_V4){ "EF_AMDGPU_FEATURE_XNACK_ON_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4 }, | |||
1601 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ANY_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ANY_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4 }, | |||
1602 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_OFF_V4){ "EF_AMDGPU_FEATURE_SRAMECC_OFF_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4 }, | |||
1603 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ON_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ON_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4 } | |||
1604 | }; | |||
1605 | ||||
1606 | const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = { | |||
1607 | ENUM_ENT(EF_RISCV_RVC, "RVC"){ "EF_RISCV_RVC", "RVC", ELF::EF_RISCV_RVC }, | |||
1608 | ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"){ "EF_RISCV_FLOAT_ABI_SINGLE", "single-float ABI", ELF::EF_RISCV_FLOAT_ABI_SINGLE }, | |||
1609 | ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"){ "EF_RISCV_FLOAT_ABI_DOUBLE", "double-float ABI", ELF::EF_RISCV_FLOAT_ABI_DOUBLE }, | |||
1610 | ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"){ "EF_RISCV_FLOAT_ABI_QUAD", "quad-float ABI", ELF::EF_RISCV_FLOAT_ABI_QUAD }, | |||
1611 | ENUM_ENT(EF_RISCV_RVE, "RVE"){ "EF_RISCV_RVE", "RVE", ELF::EF_RISCV_RVE }, | |||
1612 | ENUM_ENT(EF_RISCV_TSO, "TSO"){ "EF_RISCV_TSO", "TSO", ELF::EF_RISCV_TSO }, | |||
1613 | }; | |||
1614 | ||||
1615 | const EnumEntry<unsigned> ElfHeaderAVRFlags[] = { | |||
1616 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR1){ "EF_AVR_ARCH_AVR1", ELF::EF_AVR_ARCH_AVR1 }, | |||
1617 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR2){ "EF_AVR_ARCH_AVR2", ELF::EF_AVR_ARCH_AVR2 }, | |||
1618 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR25){ "EF_AVR_ARCH_AVR25", ELF::EF_AVR_ARCH_AVR25 }, | |||
1619 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR3){ "EF_AVR_ARCH_AVR3", ELF::EF_AVR_ARCH_AVR3 }, | |||
1620 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR31){ "EF_AVR_ARCH_AVR31", ELF::EF_AVR_ARCH_AVR31 }, | |||
1621 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR35){ "EF_AVR_ARCH_AVR35", ELF::EF_AVR_ARCH_AVR35 }, | |||
1622 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR4){ "EF_AVR_ARCH_AVR4", ELF::EF_AVR_ARCH_AVR4 }, | |||
1623 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR5){ "EF_AVR_ARCH_AVR5", ELF::EF_AVR_ARCH_AVR5 }, | |||
1624 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR51){ "EF_AVR_ARCH_AVR51", ELF::EF_AVR_ARCH_AVR51 }, | |||
1625 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR6){ "EF_AVR_ARCH_AVR6", ELF::EF_AVR_ARCH_AVR6 }, | |||
1626 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVRTINY){ "EF_AVR_ARCH_AVRTINY", ELF::EF_AVR_ARCH_AVRTINY }, | |||
1627 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA1){ "EF_AVR_ARCH_XMEGA1", ELF::EF_AVR_ARCH_XMEGA1 }, | |||
1628 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA2){ "EF_AVR_ARCH_XMEGA2", ELF::EF_AVR_ARCH_XMEGA2 }, | |||
1629 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3){ "EF_AVR_ARCH_XMEGA3", ELF::EF_AVR_ARCH_XMEGA3 }, | |||
1630 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4){ "EF_AVR_ARCH_XMEGA4", ELF::EF_AVR_ARCH_XMEGA4 }, | |||
1631 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5){ "EF_AVR_ARCH_XMEGA5", ELF::EF_AVR_ARCH_XMEGA5 }, | |||
1632 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6){ "EF_AVR_ARCH_XMEGA6", ELF::EF_AVR_ARCH_XMEGA6 }, | |||
1633 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7){ "EF_AVR_ARCH_XMEGA7", ELF::EF_AVR_ARCH_XMEGA7 }, | |||
1634 | ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"){ "EF_AVR_LINKRELAX_PREPARED", "relaxable", ELF::EF_AVR_LINKRELAX_PREPARED }, | |||
1635 | }; | |||
1636 | ||||
1637 | ||||
1638 | const EnumEntry<unsigned> ElfSymOtherFlags[] = { | |||
1639 | LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL){ "STV_INTERNAL", ELF::STV_INTERNAL }, | |||
1640 | LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN){ "STV_HIDDEN", ELF::STV_HIDDEN }, | |||
1641 | LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED){ "STV_PROTECTED", ELF::STV_PROTECTED } | |||
1642 | }; | |||
1643 | ||||
1644 | const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = { | |||
1645 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1646 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1647 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC){ "STO_MIPS_PIC", ELF::STO_MIPS_PIC }, | |||
1648 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS){ "STO_MIPS_MICROMIPS", ELF::STO_MIPS_MICROMIPS } | |||
1649 | }; | |||
1650 | ||||
1651 | const EnumEntry<unsigned> ElfAArch64SymOtherFlags[] = { | |||
1652 | LLVM_READOBJ_ENUM_ENT(ELF, STO_AARCH64_VARIANT_PCS){ "STO_AARCH64_VARIANT_PCS", ELF::STO_AARCH64_VARIANT_PCS } | |||
1653 | }; | |||
1654 | ||||
1655 | const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = { | |||
1656 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1657 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1658 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16){ "STO_MIPS_MIPS16", ELF::STO_MIPS_MIPS16 } | |||
1659 | }; | |||
1660 | ||||
1661 | const EnumEntry<unsigned> ElfRISCVSymOtherFlags[] = { | |||
1662 | LLVM_READOBJ_ENUM_ENT(ELF, STO_RISCV_VARIANT_CC){ "STO_RISCV_VARIANT_CC", ELF::STO_RISCV_VARIANT_CC }}; | |||
1663 | ||||
1664 | static const char *getElfMipsOptionsOdkType(unsigned Odk) { | |||
1665 | switch (Odk) { | |||
1666 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL)case ELF::ODK_NULL: return "ODK_NULL";; | |||
1667 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO)case ELF::ODK_REGINFO: return "ODK_REGINFO";; | |||
1668 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS)case ELF::ODK_EXCEPTIONS: return "ODK_EXCEPTIONS";; | |||
1669 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD)case ELF::ODK_PAD: return "ODK_PAD";; | |||
1670 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH)case ELF::ODK_HWPATCH: return "ODK_HWPATCH";; | |||
1671 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL)case ELF::ODK_FILL: return "ODK_FILL";; | |||
1672 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS)case ELF::ODK_TAGS: return "ODK_TAGS";; | |||
1673 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND)case ELF::ODK_HWAND: return "ODK_HWAND";; | |||
1674 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR)case ELF::ODK_HWOR: return "ODK_HWOR";; | |||
1675 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP)case ELF::ODK_GP_GROUP: return "ODK_GP_GROUP";; | |||
1676 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT)case ELF::ODK_IDENT: return "ODK_IDENT";; | |||
1677 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE)case ELF::ODK_PAGESIZE: return "ODK_PAGESIZE";; | |||
1678 | default: | |||
1679 | return "Unknown"; | |||
1680 | } | |||
1681 | } | |||
1682 | ||||
1683 | template <typename ELFT> | |||
1684 | std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *> | |||
1685 | ELFDumper<ELFT>::findDynamic() { | |||
1686 | // Try to locate the PT_DYNAMIC header. | |||
1687 | const Elf_Phdr *DynamicPhdr = nullptr; | |||
1688 | if (Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj.program_headers()) { | |||
1689 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
1690 | if (Phdr.p_type != ELF::PT_DYNAMIC) | |||
1691 | continue; | |||
1692 | DynamicPhdr = &Phdr; | |||
1693 | break; | |||
1694 | } | |||
1695 | } else { | |||
1696 | reportUniqueWarning( | |||
1697 | "unable to read program headers to locate the PT_DYNAMIC segment: " + | |||
1698 | toString(PhdrsOrErr.takeError())); | |||
1699 | } | |||
1700 | ||||
1701 | // Try to locate the .dynamic section in the sections header table. | |||
1702 | const Elf_Shdr *DynamicSec = nullptr; | |||
1703 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
1704 | if (Sec.sh_type != ELF::SHT_DYNAMIC) | |||
1705 | continue; | |||
1706 | DynamicSec = &Sec; | |||
1707 | break; | |||
1708 | } | |||
1709 | ||||
1710 | if (DynamicPhdr && ((DynamicPhdr->p_offset + DynamicPhdr->p_filesz > | |||
1711 | ObjF.getMemoryBufferRef().getBufferSize()) || | |||
1712 | (DynamicPhdr->p_offset + DynamicPhdr->p_filesz < | |||
1713 | DynamicPhdr->p_offset))) { | |||
1714 | reportUniqueWarning( | |||
1715 | "PT_DYNAMIC segment offset (0x" + | |||
1716 | Twine::utohexstr(DynamicPhdr->p_offset) + ") + file size (0x" + | |||
1717 | Twine::utohexstr(DynamicPhdr->p_filesz) + | |||
1718 | ") exceeds the size of the file (0x" + | |||
1719 | Twine::utohexstr(ObjF.getMemoryBufferRef().getBufferSize()) + ")"); | |||
1720 | // Don't use the broken dynamic header. | |||
1721 | DynamicPhdr = nullptr; | |||
1722 | } | |||
1723 | ||||
1724 | if (DynamicPhdr && DynamicSec) { | |||
1725 | if (DynamicSec->sh_addr + DynamicSec->sh_size > | |||
1726 | DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz || | |||
1727 | DynamicSec->sh_addr < DynamicPhdr->p_vaddr) | |||
1728 | reportUniqueWarning(describe(*DynamicSec) + | |||
1729 | " is not contained within the " | |||
1730 | "PT_DYNAMIC segment"); | |||
1731 | ||||
1732 | if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr) | |||
1733 | reportUniqueWarning(describe(*DynamicSec) + " is not at the start of " | |||
1734 | "PT_DYNAMIC segment"); | |||
1735 | } | |||
1736 | ||||
1737 | return std::make_pair(DynamicPhdr, DynamicSec); | |||
1738 | } | |||
1739 | ||||
1740 | template <typename ELFT> | |||
1741 | void ELFDumper<ELFT>::loadDynamicTable() { | |||
1742 | const Elf_Phdr *DynamicPhdr; | |||
1743 | const Elf_Shdr *DynamicSec; | |||
1744 | std::tie(DynamicPhdr, DynamicSec) = findDynamic(); | |||
1745 | if (!DynamicPhdr && !DynamicSec) | |||
1746 | return; | |||
1747 | ||||
1748 | DynRegionInfo FromPhdr(ObjF, *this); | |||
1749 | bool IsPhdrTableValid = false; | |||
1750 | if (DynamicPhdr) { | |||
1751 | // Use cantFail(), because p_offset/p_filesz fields of a PT_DYNAMIC are | |||
1752 | // validated in findDynamic() and so createDRI() is not expected to fail. | |||
1753 | FromPhdr = cantFail(createDRI(DynamicPhdr->p_offset, DynamicPhdr->p_filesz, | |||
1754 | sizeof(Elf_Dyn))); | |||
1755 | FromPhdr.SizePrintName = "PT_DYNAMIC size"; | |||
1756 | FromPhdr.EntSizePrintName = ""; | |||
1757 | IsPhdrTableValid = !FromPhdr.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1758 | } | |||
1759 | ||||
1760 | // Locate the dynamic table described in a section header. | |||
1761 | // Ignore sh_entsize and use the expected value for entry size explicitly. | |||
1762 | // This allows us to dump dynamic sections with a broken sh_entsize | |||
1763 | // field. | |||
1764 | DynRegionInfo FromSec(ObjF, *this); | |||
1765 | bool IsSecTableValid = false; | |||
1766 | if (DynamicSec) { | |||
1767 | Expected<DynRegionInfo> RegOrErr = | |||
1768 | createDRI(DynamicSec->sh_offset, DynamicSec->sh_size, sizeof(Elf_Dyn)); | |||
1769 | if (RegOrErr) { | |||
1770 | FromSec = *RegOrErr; | |||
1771 | FromSec.Context = describe(*DynamicSec); | |||
1772 | FromSec.EntSizePrintName = ""; | |||
1773 | IsSecTableValid = !FromSec.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1774 | } else { | |||
1775 | reportUniqueWarning("unable to read the dynamic table from " + | |||
1776 | describe(*DynamicSec) + ": " + | |||
1777 | toString(RegOrErr.takeError())); | |||
1778 | } | |||
1779 | } | |||
1780 | ||||
1781 | // When we only have information from one of the SHT_DYNAMIC section header or | |||
1782 | // PT_DYNAMIC program header, just use that. | |||
1783 | if (!DynamicPhdr || !DynamicSec) { | |||
1784 | if ((DynamicPhdr && IsPhdrTableValid) || (DynamicSec && IsSecTableValid)) { | |||
1785 | DynamicTable = DynamicPhdr ? FromPhdr : FromSec; | |||
1786 | parseDynamicTable(); | |||
1787 | } else { | |||
1788 | reportUniqueWarning("no valid dynamic table was found"); | |||
1789 | } | |||
1790 | return; | |||
1791 | } | |||
1792 | ||||
1793 | // At this point we have tables found from the section header and from the | |||
1794 | // dynamic segment. Usually they match, but we have to do sanity checks to | |||
1795 | // verify that. | |||
1796 | ||||
1797 | if (FromPhdr.Addr != FromSec.Addr) | |||
1798 | reportUniqueWarning("SHT_DYNAMIC section header and PT_DYNAMIC " | |||
1799 | "program header disagree about " | |||
1800 | "the location of the dynamic table"); | |||
1801 | ||||
1802 | if (!IsPhdrTableValid && !IsSecTableValid) { | |||
1803 | reportUniqueWarning("no valid dynamic table was found"); | |||
1804 | return; | |||
1805 | } | |||
1806 | ||||
1807 | // Information in the PT_DYNAMIC program header has priority over the | |||
1808 | // information in a section header. | |||
1809 | if (IsPhdrTableValid) { | |||
1810 | if (!IsSecTableValid) | |||
1811 | reportUniqueWarning( | |||
1812 | "SHT_DYNAMIC dynamic table is invalid: PT_DYNAMIC will be used"); | |||
1813 | DynamicTable = FromPhdr; | |||
1814 | } else { | |||
1815 | reportUniqueWarning( | |||
1816 | "PT_DYNAMIC dynamic table is invalid: SHT_DYNAMIC will be used"); | |||
1817 | DynamicTable = FromSec; | |||
1818 | } | |||
1819 | ||||
1820 | parseDynamicTable(); | |||
1821 | } | |||
1822 | ||||
1823 | template <typename ELFT> | |||
1824 | ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> &O, | |||
1825 | ScopedPrinter &Writer) | |||
1826 | : ObjDumper(Writer, O.getFileName()), ObjF(O), Obj(O.getELFFile()), | |||
1827 | FileName(O.getFileName()), DynRelRegion(O, *this), | |||
1828 | DynRelaRegion(O, *this), DynRelrRegion(O, *this), | |||
1829 | DynPLTRelRegion(O, *this), DynSymTabShndxRegion(O, *this), | |||
1830 | DynamicTable(O, *this) { | |||
1831 | if (!O.IsContentValid()) | |||
1832 | return; | |||
1833 | ||||
1834 | typename ELFT::ShdrRange Sections = cantFail(Obj.sections()); | |||
1835 | for (const Elf_Shdr &Sec : Sections) { | |||
1836 | switch (Sec.sh_type) { | |||
1837 | case ELF::SHT_SYMTAB: | |||
1838 | if (!DotSymtabSec) | |||
1839 | DotSymtabSec = &Sec; | |||
1840 | break; | |||
1841 | case ELF::SHT_DYNSYM: | |||
1842 | if (!DotDynsymSec) | |||
1843 | DotDynsymSec = &Sec; | |||
1844 | ||||
1845 | if (!DynSymRegion) { | |||
1846 | Expected<DynRegionInfo> RegOrErr = | |||
1847 | createDRI(Sec.sh_offset, Sec.sh_size, Sec.sh_entsize); | |||
1848 | if (RegOrErr) { | |||
1849 | DynSymRegion = *RegOrErr; | |||
1850 | DynSymRegion->Context = describe(Sec); | |||
1851 | ||||
1852 | if (Expected<StringRef> E = Obj.getStringTableForSymtab(Sec)) | |||
1853 | DynamicStringTable = *E; | |||
1854 | else | |||
1855 | reportUniqueWarning("unable to get the string table for the " + | |||
1856 | describe(Sec) + ": " + toString(E.takeError())); | |||
1857 | } else { | |||
1858 | reportUniqueWarning("unable to read dynamic symbols from " + | |||
1859 | describe(Sec) + ": " + | |||
1860 | toString(RegOrErr.takeError())); | |||
1861 | } | |||
1862 | } | |||
1863 | break; | |||
1864 | case ELF::SHT_SYMTAB_SHNDX: { | |||
1865 | uint32_t SymtabNdx = Sec.sh_link; | |||
1866 | if (SymtabNdx >= Sections.size()) { | |||
1867 | reportUniqueWarning( | |||
1868 | "unable to get the associated symbol table for " + describe(Sec) + | |||
1869 | ": sh_link (" + Twine(SymtabNdx) + | |||
1870 | ") is greater than or equal to the total number of sections (" + | |||
1871 | Twine(Sections.size()) + ")"); | |||
1872 | continue; | |||
1873 | } | |||
1874 | ||||
1875 | if (Expected<ArrayRef<Elf_Word>> ShndxTableOrErr = | |||
1876 | Obj.getSHNDXTable(Sec)) { | |||
1877 | if (!ShndxTables.insert({&Sections[SymtabNdx], *ShndxTableOrErr}) | |||
1878 | .second) | |||
1879 | reportUniqueWarning( | |||
1880 | "multiple SHT_SYMTAB_SHNDX sections are linked to " + | |||
1881 | describe(Sec)); | |||
1882 | } else { | |||
1883 | reportUniqueWarning(ShndxTableOrErr.takeError()); | |||
1884 | } | |||
1885 | break; | |||
1886 | } | |||
1887 | case ELF::SHT_GNU_versym: | |||
1888 | if (!SymbolVersionSection) | |||
1889 | SymbolVersionSection = &Sec; | |||
1890 | break; | |||
1891 | case ELF::SHT_GNU_verdef: | |||
1892 | if (!SymbolVersionDefSection) | |||
1893 | SymbolVersionDefSection = &Sec; | |||
1894 | break; | |||
1895 | case ELF::SHT_GNU_verneed: | |||
1896 | if (!SymbolVersionNeedSection) | |||
1897 | SymbolVersionNeedSection = &Sec; | |||
1898 | break; | |||
1899 | case ELF::SHT_LLVM_ADDRSIG: | |||
1900 | if (!DotAddrsigSec) | |||
1901 | DotAddrsigSec = &Sec; | |||
1902 | break; | |||
1903 | } | |||
1904 | } | |||
1905 | ||||
1906 | loadDynamicTable(); | |||
1907 | } | |||
1908 | ||||
1909 | template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() { | |||
1910 | auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * { | |||
1911 | auto MappedAddrOrError = Obj.toMappedAddr(VAddr, [&](const Twine &Msg) { | |||
1912 | this->reportUniqueWarning(Msg); | |||
1913 | return Error::success(); | |||
1914 | }); | |||
1915 | if (!MappedAddrOrError) { | |||
1916 | this->reportUniqueWarning("unable to parse DT_" + | |||
1917 | Obj.getDynamicTagAsString(Tag) + ": " + | |||
1918 | llvm::toString(MappedAddrOrError.takeError())); | |||
1919 | return nullptr; | |||
1920 | } | |||
1921 | return MappedAddrOrError.get(); | |||
1922 | }; | |||
1923 | ||||
1924 | const char *StringTableBegin = nullptr; | |||
1925 | uint64_t StringTableSize = 0; | |||
1926 | Optional<DynRegionInfo> DynSymFromTable; | |||
1927 | for (const Elf_Dyn &Dyn : dynamic_table()) { | |||
1928 | switch (Dyn.d_tag) { | |||
1929 | case ELF::DT_HASH: | |||
1930 | HashTable = reinterpret_cast<const Elf_Hash *>( | |||
1931 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1932 | break; | |||
1933 | case ELF::DT_GNU_HASH: | |||
1934 | GnuHashTable = reinterpret_cast<const Elf_GnuHash *>( | |||
1935 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1936 | break; | |||
1937 | case ELF::DT_STRTAB: | |||
1938 | StringTableBegin = reinterpret_cast<const char *>( | |||
1939 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1940 | break; | |||
1941 | case ELF::DT_STRSZ: | |||
1942 | StringTableSize = Dyn.getVal(); | |||
1943 | break; | |||
1944 | case ELF::DT_SYMTAB: { | |||
1945 | // If we can't map the DT_SYMTAB value to an address (e.g. when there are | |||
1946 | // no program headers), we ignore its value. | |||
1947 | if (const uint8_t *VA = toMappedAddr(Dyn.getTag(), Dyn.getPtr())) { | |||
1948 | DynSymFromTable.emplace(ObjF, *this); | |||
1949 | DynSymFromTable->Addr = VA; | |||
1950 | DynSymFromTable->EntSize = sizeof(Elf_Sym); | |||
1951 | DynSymFromTable->EntSizePrintName = ""; | |||
1952 | } | |||
1953 | break; | |||
1954 | } | |||
1955 | case ELF::DT_SYMENT: { | |||
1956 | uint64_t Val = Dyn.getVal(); | |||
1957 | if (Val != sizeof(Elf_Sym)) | |||
1958 | this->reportUniqueWarning("DT_SYMENT value of 0x" + | |||
1959 | Twine::utohexstr(Val) + | |||
1960 | " is not the size of a symbol (0x" + | |||
1961 | Twine::utohexstr(sizeof(Elf_Sym)) + ")"); | |||
1962 | break; | |||
1963 | } | |||
1964 | case ELF::DT_RELA: | |||
1965 | DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
1966 | break; | |||
1967 | case ELF::DT_RELASZ: | |||
1968 | DynRelaRegion.Size = Dyn.getVal(); | |||
1969 | DynRelaRegion.SizePrintName = "DT_RELASZ value"; | |||
1970 | break; | |||
1971 | case ELF::DT_RELAENT: | |||
1972 | DynRelaRegion.EntSize = Dyn.getVal(); | |||
1973 | DynRelaRegion.EntSizePrintName = "DT_RELAENT value"; | |||
1974 | break; | |||
1975 | case ELF::DT_SONAME: | |||
1976 | SONameOffset = Dyn.getVal(); | |||
1977 | break; | |||
1978 | case ELF::DT_REL: | |||
1979 | DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
1980 | break; | |||
1981 | case ELF::DT_RELSZ: | |||
1982 | DynRelRegion.Size = Dyn.getVal(); | |||
1983 | DynRelRegion.SizePrintName = "DT_RELSZ value"; | |||
1984 | break; | |||
1985 | case ELF::DT_RELENT: | |||
1986 | DynRelRegion.EntSize = Dyn.getVal(); | |||
1987 | DynRelRegion.EntSizePrintName = "DT_RELENT value"; | |||
1988 | break; | |||
1989 | case ELF::DT_RELR: | |||
1990 | case ELF::DT_ANDROID_RELR: | |||
1991 | DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
1992 | break; | |||
1993 | case ELF::DT_RELRSZ: | |||
1994 | case ELF::DT_ANDROID_RELRSZ: | |||
1995 | DynRelrRegion.Size = Dyn.getVal(); | |||
1996 | DynRelrRegion.SizePrintName = Dyn.d_tag == ELF::DT_RELRSZ | |||
1997 | ? "DT_RELRSZ value" | |||
1998 | : "DT_ANDROID_RELRSZ value"; | |||
1999 | break; | |||
2000 | case ELF::DT_RELRENT: | |||
2001 | case ELF::DT_ANDROID_RELRENT: | |||
2002 | DynRelrRegion.EntSize = Dyn.getVal(); | |||
2003 | DynRelrRegion.EntSizePrintName = Dyn.d_tag == ELF::DT_RELRENT | |||
2004 | ? "DT_RELRENT value" | |||
2005 | : "DT_ANDROID_RELRENT value"; | |||
2006 | break; | |||
2007 | case ELF::DT_PLTREL: | |||
2008 | if (Dyn.getVal() == DT_REL) | |||
2009 | DynPLTRelRegion.EntSize = sizeof(Elf_Rel); | |||
2010 | else if (Dyn.getVal() == DT_RELA) | |||
2011 | DynPLTRelRegion.EntSize = sizeof(Elf_Rela); | |||
2012 | else | |||
2013 | reportUniqueWarning(Twine("unknown DT_PLTREL value of ") + | |||
2014 | Twine((uint64_t)Dyn.getVal())); | |||
2015 | DynPLTRelRegion.EntSizePrintName = "PLTREL entry size"; | |||
2016 | break; | |||
2017 | case ELF::DT_JMPREL: | |||
2018 | DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2019 | break; | |||
2020 | case ELF::DT_PLTRELSZ: | |||
2021 | DynPLTRelRegion.Size = Dyn.getVal(); | |||
2022 | DynPLTRelRegion.SizePrintName = "DT_PLTRELSZ value"; | |||
2023 | break; | |||
2024 | case ELF::DT_SYMTAB_SHNDX: | |||
2025 | DynSymTabShndxRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2026 | DynSymTabShndxRegion.EntSize = sizeof(Elf_Word); | |||
2027 | break; | |||
2028 | } | |||
2029 | } | |||
2030 | ||||
2031 | if (StringTableBegin) { | |||
2032 | const uint64_t FileSize = Obj.getBufSize(); | |||
2033 | const uint64_t Offset = (const uint8_t *)StringTableBegin - Obj.base(); | |||
2034 | if (StringTableSize > FileSize - Offset) | |||
2035 | reportUniqueWarning( | |||
2036 | "the dynamic string table at 0x" + Twine::utohexstr(Offset) + | |||
2037 | " goes past the end of the file (0x" + Twine::utohexstr(FileSize) + | |||
2038 | ") with DT_STRSZ = 0x" + Twine::utohexstr(StringTableSize)); | |||
2039 | else | |||
2040 | DynamicStringTable = StringRef(StringTableBegin, StringTableSize); | |||
2041 | } | |||
2042 | ||||
2043 | const bool IsHashTableSupported = getHashTableEntSize() == 4; | |||
2044 | if (DynSymRegion) { | |||
2045 | // Often we find the information about the dynamic symbol table | |||
2046 | // location in the SHT_DYNSYM section header. However, the value in | |||
2047 | // DT_SYMTAB has priority, because it is used by dynamic loaders to | |||
2048 | // locate .dynsym at runtime. The location we find in the section header | |||
2049 | // and the location we find here should match. | |||
2050 | if (DynSymFromTable && DynSymFromTable->Addr != DynSymRegion->Addr) | |||
2051 | reportUniqueWarning( | |||
2052 | createError("SHT_DYNSYM section header and DT_SYMTAB disagree about " | |||
2053 | "the location of the dynamic symbol table")); | |||
2054 | ||||
2055 | // According to the ELF gABI: "The number of symbol table entries should | |||
2056 | // equal nchain". Check to see if the DT_HASH hash table nchain value | |||
2057 | // conflicts with the number of symbols in the dynamic symbol table | |||
2058 | // according to the section header. | |||
2059 | if (HashTable && IsHashTableSupported) { | |||
2060 | if (DynSymRegion->EntSize == 0) | |||
2061 | reportUniqueWarning("SHT_DYNSYM section has sh_entsize == 0"); | |||
2062 | else if (HashTable->nchain != DynSymRegion->Size / DynSymRegion->EntSize) | |||
2063 | reportUniqueWarning( | |||
2064 | "hash table nchain (" + Twine(HashTable->nchain) + | |||
2065 | ") differs from symbol count derived from SHT_DYNSYM section " | |||
2066 | "header (" + | |||
2067 | Twine(DynSymRegion->Size / DynSymRegion->EntSize) + ")"); | |||
2068 | } | |||
2069 | } | |||
2070 | ||||
2071 | // Delay the creation of the actual dynamic symbol table until now, so that | |||
2072 | // checks can always be made against the section header-based properties, | |||
2073 | // without worrying about tag order. | |||
2074 | if (DynSymFromTable) { | |||
2075 | if (!DynSymRegion) { | |||
2076 | DynSymRegion = DynSymFromTable; | |||
2077 | } else { | |||
2078 | DynSymRegion->Addr = DynSymFromTable->Addr; | |||
2079 | DynSymRegion->EntSize = DynSymFromTable->EntSize; | |||
2080 | DynSymRegion->EntSizePrintName = DynSymFromTable->EntSizePrintName; | |||
2081 | } | |||
2082 | } | |||
2083 | ||||
2084 | // Derive the dynamic symbol table size from the DT_HASH hash table, if | |||
2085 | // present. | |||
2086 | if (HashTable && IsHashTableSupported && DynSymRegion) { | |||
2087 | const uint64_t FileSize = Obj.getBufSize(); | |||
2088 | const uint64_t DerivedSize = | |||
2089 | (uint64_t)HashTable->nchain * DynSymRegion->EntSize; | |||
2090 | const uint64_t Offset = (const uint8_t *)DynSymRegion->Addr - Obj.base(); | |||
2091 | if (DerivedSize > FileSize - Offset) | |||
2092 | reportUniqueWarning( | |||
2093 | "the size (0x" + Twine::utohexstr(DerivedSize) + | |||
2094 | ") of the dynamic symbol table at 0x" + Twine::utohexstr(Offset) + | |||
2095 | ", derived from the hash table, goes past the end of the file (0x" + | |||
2096 | Twine::utohexstr(FileSize) + ") and will be ignored"); | |||
2097 | else | |||
2098 | DynSymRegion->Size = HashTable->nchain * DynSymRegion->EntSize; | |||
2099 | } | |||
2100 | } | |||
2101 | ||||
2102 | template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { | |||
2103 | // Dump version symbol section. | |||
2104 | printVersionSymbolSection(SymbolVersionSection); | |||
2105 | ||||
2106 | // Dump version definition section. | |||
2107 | printVersionDefinitionSection(SymbolVersionDefSection); | |||
2108 | ||||
2109 | // Dump version dependency section. | |||
2110 | printVersionDependencySection(SymbolVersionNeedSection); | |||
2111 | } | |||
2112 | ||||
2113 | #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ | |||
2114 | { #enum, prefix##_##enum } | |||
2115 | ||||
2116 | const EnumEntry<unsigned> ElfDynamicDTFlags[] = { | |||
2117 | LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), | |||
2118 | LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), | |||
2119 | LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), | |||
2120 | LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), | |||
2121 | LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) | |||
2122 | }; | |||
2123 | ||||
2124 | const EnumEntry<unsigned> ElfDynamicDTFlags1[] = { | |||
2125 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), | |||
2126 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), | |||
2127 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), | |||
2128 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), | |||
2129 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), | |||
2130 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), | |||
2131 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), | |||
2132 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), | |||
2133 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), | |||
2134 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), | |||
2135 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), | |||
2136 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), | |||
2137 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), | |||
2138 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), | |||
2139 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), | |||
2140 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), | |||
2141 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND), | |||
2142 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), | |||
2143 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), | |||
2144 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), | |||
2145 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), | |||
2146 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), | |||
2147 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), | |||
2148 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), | |||
2149 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), | |||
2150 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON), | |||
2151 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE), | |||
2152 | }; | |||
2153 | ||||
2154 | const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = { | |||
2155 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), | |||
2156 | LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), | |||
2157 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), | |||
2158 | LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), | |||
2159 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), | |||
2160 | LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), | |||
2161 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), | |||
2162 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), | |||
2163 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), | |||
2164 | LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), | |||
2165 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), | |||
2166 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), | |||
2167 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), | |||
2168 | LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), | |||
2169 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), | |||
2170 | LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) | |||
2171 | }; | |||
2172 | ||||
2173 | #undef LLVM_READOBJ_DT_FLAG_ENT | |||
2174 | ||||
2175 | template <typename T, typename TFlag> | |||
2176 | void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) { | |||
2177 | SmallVector<EnumEntry<TFlag>, 10> SetFlags; | |||
2178 | for (const EnumEntry<TFlag> &Flag : Flags) | |||
2179 | if (Flag.Value != 0 && (Value & Flag.Value) == Flag.Value) | |||
2180 | SetFlags.push_back(Flag); | |||
2181 | ||||
2182 | for (const EnumEntry<TFlag> &Flag : SetFlags) | |||
2183 | OS << Flag.Name << " "; | |||
2184 | } | |||
2185 | ||||
2186 | template <class ELFT> | |||
2187 | const typename ELFT::Shdr * | |||
2188 | ELFDumper<ELFT>::findSectionByName(StringRef Name) const { | |||
2189 | for (const Elf_Shdr &Shdr : cantFail(Obj.sections())) { | |||
2190 | if (Expected<StringRef> NameOrErr = Obj.getSectionName(Shdr)) { | |||
2191 | if (*NameOrErr == Name) | |||
2192 | return &Shdr; | |||
2193 | } else { | |||
2194 | reportUniqueWarning("unable to read the name of " + describe(Shdr) + | |||
2195 | ": " + toString(NameOrErr.takeError())); | |||
2196 | } | |||
2197 | } | |||
2198 | return nullptr; | |||
2199 | } | |||
2200 | ||||
2201 | template <class ELFT> | |||
2202 | std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type, | |||
2203 | uint64_t Value) const { | |||
2204 | auto FormatHexValue = [](uint64_t V) { | |||
2205 | std::string Str; | |||
2206 | raw_string_ostream OS(Str); | |||
2207 | const char *ConvChar = | |||
2208 | (opts::Output == opts::GNU) ? "0x%" PRIx64"l" "x" : "0x%" PRIX64"l" "X"; | |||
2209 | OS << format(ConvChar, V); | |||
2210 | return OS.str(); | |||
2211 | }; | |||
2212 | ||||
2213 | auto FormatFlags = [](uint64_t V, | |||
2214 | llvm::ArrayRef<llvm::EnumEntry<unsigned int>> Array) { | |||
2215 | std::string Str; | |||
2216 | raw_string_ostream OS(Str); | |||
2217 | printFlags(V, Array, OS); | |||
2218 | return OS.str(); | |||
2219 | }; | |||
2220 | ||||
2221 | // Handle custom printing of architecture specific tags | |||
2222 | switch (Obj.getHeader().e_machine) { | |||
2223 | case EM_AARCH64: | |||
2224 | switch (Type) { | |||
2225 | case DT_AARCH64_BTI_PLT: | |||
2226 | case DT_AARCH64_PAC_PLT: | |||
2227 | case DT_AARCH64_VARIANT_PCS: | |||
2228 | return std::to_string(Value); | |||
2229 | default: | |||
2230 | break; | |||
2231 | } | |||
2232 | break; | |||
2233 | case EM_HEXAGON: | |||
2234 | switch (Type) { | |||
2235 | case DT_HEXAGON_VER: | |||
2236 | return std::to_string(Value); | |||
2237 | case DT_HEXAGON_SYMSZ: | |||
2238 | case DT_HEXAGON_PLT: | |||
2239 | return FormatHexValue(Value); | |||
2240 | default: | |||
2241 | break; | |||
2242 | } | |||
2243 | break; | |||
2244 | case EM_MIPS: | |||
2245 | switch (Type) { | |||
2246 | case DT_MIPS_RLD_VERSION: | |||
2247 | case DT_MIPS_LOCAL_GOTNO: | |||
2248 | case DT_MIPS_SYMTABNO: | |||
2249 | case DT_MIPS_UNREFEXTNO: | |||
2250 | return std::to_string(Value); | |||
2251 | case DT_MIPS_TIME_STAMP: | |||
2252 | case DT_MIPS_ICHECKSUM: | |||
2253 | case DT_MIPS_IVERSION: | |||
2254 | case DT_MIPS_BASE_ADDRESS: | |||
2255 | case DT_MIPS_MSYM: | |||
2256 | case DT_MIPS_CONFLICT: | |||
2257 | case DT_MIPS_LIBLIST: | |||
2258 | case DT_MIPS_CONFLICTNO: | |||
2259 | case DT_MIPS_LIBLISTNO: | |||
2260 | case DT_MIPS_GOTSYM: | |||
2261 | case DT_MIPS_HIPAGENO: | |||
2262 | case DT_MIPS_RLD_MAP: | |||
2263 | case DT_MIPS_DELTA_CLASS: | |||
2264 | case DT_MIPS_DELTA_CLASS_NO: | |||
2265 | case DT_MIPS_DELTA_INSTANCE: | |||
2266 | case DT_MIPS_DELTA_RELOC: | |||
2267 | case DT_MIPS_DELTA_RELOC_NO: | |||
2268 | case DT_MIPS_DELTA_SYM: | |||
2269 | case DT_MIPS_DELTA_SYM_NO: | |||
2270 | case DT_MIPS_DELTA_CLASSSYM: | |||
2271 | case DT_MIPS_DELTA_CLASSSYM_NO: | |||
2272 | case DT_MIPS_CXX_FLAGS: | |||
2273 | case DT_MIPS_PIXIE_INIT: | |||
2274 | case DT_MIPS_SYMBOL_LIB: | |||
2275 | case DT_MIPS_LOCALPAGE_GOTIDX: | |||
2276 | case DT_MIPS_LOCAL_GOTIDX: | |||
2277 | case DT_MIPS_HIDDEN_GOTIDX: | |||
2278 | case DT_MIPS_PROTECTED_GOTIDX: | |||
2279 | case DT_MIPS_OPTIONS: | |||
2280 | case DT_MIPS_INTERFACE: | |||
2281 | case DT_MIPS_DYNSTR_ALIGN: | |||
2282 | case DT_MIPS_INTERFACE_SIZE: | |||
2283 | case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: | |||
2284 | case DT_MIPS_PERF_SUFFIX: | |||
2285 | case DT_MIPS_COMPACT_SIZE: | |||
2286 | case DT_MIPS_GP_VALUE: | |||
2287 | case DT_MIPS_AUX_DYNAMIC: | |||
2288 | case DT_MIPS_PLTGOT: | |||
2289 | case DT_MIPS_RWPLT: | |||
2290 | case DT_MIPS_RLD_MAP_REL: | |||
2291 | case DT_MIPS_XHASH: | |||
2292 | return FormatHexValue(Value); | |||
2293 | case DT_MIPS_FLAGS: | |||
2294 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags)); | |||
2295 | default: | |||
2296 | break; | |||
2297 | } | |||
2298 | break; | |||
2299 | default: | |||
2300 | break; | |||
2301 | } | |||
2302 | ||||
2303 | switch (Type) { | |||
2304 | case DT_PLTREL: | |||
2305 | if (Value == DT_REL) | |||
2306 | return "REL"; | |||
2307 | if (Value == DT_RELA) | |||
2308 | return "RELA"; | |||
2309 | LLVM_FALLTHROUGH[[gnu::fallthrough]]; | |||
2310 | case DT_PLTGOT: | |||
2311 | case DT_HASH: | |||
2312 | case DT_STRTAB: | |||
2313 | case DT_SYMTAB: | |||
2314 | case DT_RELA: | |||
2315 | case DT_INIT: | |||
2316 | case DT_FINI: | |||
2317 | case DT_REL: | |||
2318 | case DT_JMPREL: | |||
2319 | case DT_INIT_ARRAY: | |||
2320 | case DT_FINI_ARRAY: | |||
2321 | case DT_PREINIT_ARRAY: | |||
2322 | case DT_DEBUG: | |||
2323 | case DT_VERDEF: | |||
2324 | case DT_VERNEED: | |||
2325 | case DT_VERSYM: | |||
2326 | case DT_GNU_HASH: | |||
2327 | case DT_NULL: | |||
2328 | return FormatHexValue(Value); | |||
2329 | case DT_RELACOUNT: | |||
2330 | case DT_RELCOUNT: | |||
2331 | case DT_VERDEFNUM: | |||
2332 | case DT_VERNEEDNUM: | |||
2333 | return std::to_string(Value); | |||
2334 | case DT_PLTRELSZ: | |||
2335 | case DT_RELASZ: | |||
2336 | case DT_RELAENT: | |||
2337 | case DT_STRSZ: | |||
2338 | case DT_SYMENT: | |||
2339 | case DT_RELSZ: | |||
2340 | case DT_RELENT: | |||
2341 | case DT_INIT_ARRAYSZ: | |||
2342 | case DT_FINI_ARRAYSZ: | |||
2343 | case DT_PREINIT_ARRAYSZ: | |||
2344 | case DT_RELRSZ: | |||
2345 | case DT_RELRENT: | |||
2346 | case DT_ANDROID_RELSZ: | |||
2347 | case DT_ANDROID_RELASZ: | |||
2348 | return std::to_string(Value) + " (bytes)"; | |||
2349 | case DT_NEEDED: | |||
2350 | case DT_SONAME: | |||
2351 | case DT_AUXILIARY: | |||
2352 | case DT_USED: | |||
2353 | case DT_FILTER: | |||
2354 | case DT_RPATH: | |||
2355 | case DT_RUNPATH: { | |||
2356 | const std::map<uint64_t, const char *> TagNames = { | |||
2357 | {DT_NEEDED, "Shared library"}, {DT_SONAME, "Library soname"}, | |||
2358 | {DT_AUXILIARY, "Auxiliary library"}, {DT_USED, "Not needed object"}, | |||
2359 | {DT_FILTER, "Filter library"}, {DT_RPATH, "Library rpath"}, | |||
2360 | {DT_RUNPATH, "Library runpath"}, | |||
2361 | }; | |||
2362 | ||||
2363 | return (Twine(TagNames.at(Type)) + ": [" + getDynamicString(Value) + "]") | |||
2364 | .str(); | |||
2365 | } | |||
2366 | case DT_FLAGS: | |||
2367 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags)); | |||
2368 | case DT_FLAGS_1: | |||
2369 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags1)); | |||
2370 | default: | |||
2371 | return FormatHexValue(Value); | |||
2372 | } | |||
2373 | } | |||
2374 | ||||
2375 | template <class ELFT> | |||
2376 | StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { | |||
2377 | if (DynamicStringTable.empty() && !DynamicStringTable.data()) { | |||
2378 | reportUniqueWarning("string table was not found"); | |||
2379 | return "<?>"; | |||
2380 | } | |||
2381 | ||||
2382 | auto WarnAndReturn = [this](const Twine &Msg, uint64_t Offset) { | |||
2383 | reportUniqueWarning("string table at offset 0x" + Twine::utohexstr(Offset) + | |||
2384 | Msg); | |||
2385 | return "<?>"; | |||
2386 | }; | |||
2387 | ||||
2388 | const uint64_t FileSize = Obj.getBufSize(); | |||
2389 | const uint64_t Offset = | |||
2390 | (const uint8_t *)DynamicStringTable.data() - Obj.base(); | |||
2391 | if (DynamicStringTable.size() > FileSize - Offset) | |||
2392 | return WarnAndReturn(" with size 0x" + | |||
2393 | Twine::utohexstr(DynamicStringTable.size()) + | |||
2394 | " goes past the end of the file (0x" + | |||
2395 | Twine::utohexstr(FileSize) + ")", | |||
2396 | Offset); | |||
2397 | ||||
2398 | if (Value >= DynamicStringTable.size()) | |||
2399 | return WarnAndReturn( | |||
2400 | ": unable to read the string at 0x" + Twine::utohexstr(Offset + Value) + | |||
2401 | ": it goes past the end of the table (0x" + | |||
2402 | Twine::utohexstr(Offset + DynamicStringTable.size()) + ")", | |||
2403 | Offset); | |||
2404 | ||||
2405 | if (DynamicStringTable.back() != '\0') | |||
2406 | return WarnAndReturn(": unable to read the string at 0x" + | |||
2407 | Twine::utohexstr(Offset + Value) + | |||
2408 | ": the string table is not null-terminated", | |||
2409 | Offset); | |||
2410 | ||||
2411 | return DynamicStringTable.data() + Value; | |||
2412 | } | |||
2413 | ||||
2414 | template <class ELFT> void ELFDumper<ELFT>::printUnwindInfo() { | |||
2415 | DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF); | |||
2416 | Ctx.printUnwindInformation(); | |||
2417 | } | |||
2418 | ||||
2419 | // The namespace is needed to fix the compilation with GCC older than 7.0+. | |||
2420 | namespace { | |||
2421 | template <> void ELFDumper<ELF32LE>::printUnwindInfo() { | |||
2422 | if (Obj.getHeader().e_machine == EM_ARM) { | |||
2423 | ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF.getFileName(), | |||
2424 | DotSymtabSec); | |||
2425 | Ctx.PrintUnwindInformation(); | |||
2426 | } | |||
2427 | DwarfCFIEH::PrinterContext<ELF32LE> Ctx(W, ObjF); | |||
2428 | Ctx.printUnwindInformation(); | |||
2429 | } | |||
2430 | } // namespace | |||
2431 | ||||
2432 | template <class ELFT> void ELFDumper<ELFT>::printNeededLibraries() { | |||
2433 | ListScope D(W, "NeededLibraries"); | |||
2434 | ||||
2435 | std::vector<StringRef> Libs; | |||
2436 | for (const auto &Entry : dynamic_table()) | |||
2437 | if (Entry.d_tag == ELF::DT_NEEDED) | |||
2438 | Libs.push_back(getDynamicString(Entry.d_un.d_val)); | |||
2439 | ||||
2440 | llvm::sort(Libs); | |||
2441 | ||||
2442 | for (StringRef L : Libs) | |||
2443 | W.startLine() << L << "\n"; | |||
2444 | } | |||
2445 | ||||
2446 | template <class ELFT> | |||
2447 | static Error checkHashTable(const ELFDumper<ELFT> &Dumper, | |||
2448 | const typename ELFT::Hash *H, | |||
2449 | bool *IsHeaderValid = nullptr) { | |||
2450 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
2451 | const uint64_t SecOffset = (const uint8_t *)H - Obj.base(); | |||
2452 | if (Dumper.getHashTableEntSize() == 8) { | |||
2453 | auto It = llvm::find_if(ElfMachineType, [&](const EnumEntry<unsigned> &E) { | |||
2454 | return E.Value == Obj.getHeader().e_machine; | |||
2455 | }); | |||
2456 | if (IsHeaderValid) | |||
2457 | *IsHeaderValid = false; | |||
2458 | return createError("the hash table at 0x" + Twine::utohexstr(SecOffset) + | |||
2459 | " is not supported: it contains non-standard 8 " | |||
2460 | "byte entries on " + | |||
2461 | It->AltName + " platform"); | |||
2462 | } | |||
2463 | ||||
2464 | auto MakeError = [&](const Twine &Msg = "") { | |||
2465 | return createError("the hash table at offset 0x" + | |||
2466 | Twine::utohexstr(SecOffset) + | |||
2467 | " goes past the end of the file (0x" + | |||
2468 | Twine::utohexstr(Obj.getBufSize()) + ")" + Msg); | |||
2469 | }; | |||
2470 | ||||
2471 | // Each SHT_HASH section starts from two 32-bit fields: nbucket and nchain. | |||
2472 | const unsigned HeaderSize = 2 * sizeof(typename ELFT::Word); | |||
2473 | ||||
2474 | if (IsHeaderValid) | |||
2475 | *IsHeaderValid = Obj.getBufSize() - SecOffset >= HeaderSize; | |||
2476 | ||||
2477 | if (Obj.getBufSize() - SecOffset < HeaderSize) | |||
2478 | return MakeError(); | |||
2479 | ||||
2480 | if (Obj.getBufSize() - SecOffset - HeaderSize < | |||
2481 | ((uint64_t)H->nbucket + H->nchain) * sizeof(typename ELFT::Word)) | |||
2482 | return MakeError(", nbucket = " + Twine(H->nbucket) + | |||
2483 | ", nchain = " + Twine(H->nchain)); | |||
2484 | return Error::success(); | |||
2485 | } | |||
2486 | ||||
2487 | template <class ELFT> | |||
2488 | static Error checkGNUHashTable(const ELFFile<ELFT> &Obj, | |||
2489 | const typename ELFT::GnuHash *GnuHashTable, | |||
2490 | bool *IsHeaderValid = nullptr) { | |||
2491 | const uint8_t *TableData = reinterpret_cast<const uint8_t *>(GnuHashTable); | |||
2492 | assert(TableData >= Obj.base() && TableData < Obj.base() + Obj.getBufSize() &&(static_cast <bool> (TableData >= Obj.base() && TableData < Obj.base() + Obj.getBufSize() && "GnuHashTable must always point to a location inside the file" ) ? void (0) : __assert_fail ("TableData >= Obj.base() && TableData < Obj.base() + Obj.getBufSize() && \"GnuHashTable must always point to a location inside the file\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 2493, __extension__ __PRETTY_FUNCTION__)) | |||
2493 | "GnuHashTable must always point to a location inside the file")(static_cast <bool> (TableData >= Obj.base() && TableData < Obj.base() + Obj.getBufSize() && "GnuHashTable must always point to a location inside the file" ) ? void (0) : __assert_fail ("TableData >= Obj.base() && TableData < Obj.base() + Obj.getBufSize() && \"GnuHashTable must always point to a location inside the file\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 2493, __extension__ __PRETTY_FUNCTION__)); | |||
2494 | ||||
2495 | uint64_t TableOffset = TableData - Obj.base(); | |||
2496 | if (IsHeaderValid) | |||
2497 | *IsHeaderValid = TableOffset + /*Header size:*/ 16 < Obj.getBufSize(); | |||
2498 | if (TableOffset + 16 + (uint64_t)GnuHashTable->nbuckets * 4 + | |||
2499 | (uint64_t)GnuHashTable->maskwords * sizeof(typename ELFT::Off) >= | |||
2500 | Obj.getBufSize()) | |||
2501 | return createError("unable to dump the SHT_GNU_HASH " | |||
2502 | "section at 0x" + | |||
2503 | Twine::utohexstr(TableOffset) + | |||
2504 | ": it goes past the end of the file"); | |||
2505 | return Error::success(); | |||
2506 | } | |||
2507 | ||||
2508 | template <typename ELFT> void ELFDumper<ELFT>::printHashTable() { | |||
2509 | DictScope D(W, "HashTable"); | |||
2510 | if (!HashTable) | |||
2511 | return; | |||
2512 | ||||
2513 | bool IsHeaderValid; | |||
2514 | Error Err = checkHashTable(*this, HashTable, &IsHeaderValid); | |||
2515 | if (IsHeaderValid) { | |||
2516 | W.printNumber("Num Buckets", HashTable->nbucket); | |||
2517 | W.printNumber("Num Chains", HashTable->nchain); | |||
2518 | } | |||
2519 | ||||
2520 | if (Err) { | |||
2521 | reportUniqueWarning(std::move(Err)); | |||
2522 | return; | |||
2523 | } | |||
2524 | ||||
2525 | W.printList("Buckets", HashTable->buckets()); | |||
2526 | W.printList("Chains", HashTable->chains()); | |||
2527 | } | |||
2528 | ||||
2529 | template <class ELFT> | |||
2530 | static Expected<ArrayRef<typename ELFT::Word>> | |||
2531 | getGnuHashTableChains(Optional<DynRegionInfo> DynSymRegion, | |||
2532 | const typename ELFT::GnuHash *GnuHashTable) { | |||
2533 | if (!DynSymRegion) | |||
2534 | return createError("no dynamic symbol table found"); | |||
2535 | ||||
2536 | ArrayRef<typename ELFT::Sym> DynSymTable = | |||
2537 | DynSymRegion->template getAsArrayRef<typename ELFT::Sym>(); | |||
2538 | size_t NumSyms = DynSymTable.size(); | |||
2539 | if (!NumSyms) | |||
2540 | return createError("the dynamic symbol table is empty"); | |||
2541 | ||||
2542 | if (GnuHashTable->symndx < NumSyms) | |||
2543 | return GnuHashTable->values(NumSyms); | |||
2544 | ||||
2545 | // A normal empty GNU hash table section produced by linker might have | |||
2546 | // symndx set to the number of dynamic symbols + 1 (for the zero symbol) | |||
2547 | // and have dummy null values in the Bloom filter and in the buckets | |||
2548 | // vector (or no values at all). It happens because the value of symndx is not | |||
2549 | // important for dynamic loaders when the GNU hash table is empty. They just | |||
2550 | // skip the whole object during symbol lookup. In such cases, the symndx value | |||
2551 | // is irrelevant and we should not report a warning. | |||
2552 | ArrayRef<typename ELFT::Word> Buckets = GnuHashTable->buckets(); | |||
2553 | if (!llvm::all_of(Buckets, [](typename ELFT::Word V) { return V == 0; })) | |||
2554 | return createError( | |||
2555 | "the first hashed symbol index (" + Twine(GnuHashTable->symndx) + | |||
2556 | ") is greater than or equal to the number of dynamic symbols (" + | |||
2557 | Twine(NumSyms) + ")"); | |||
2558 | // There is no way to represent an array of (dynamic symbols count - symndx) | |||
2559 | // length. | |||
2560 | return ArrayRef<typename ELFT::Word>(); | |||
2561 | } | |||
2562 | ||||
2563 | template <typename ELFT> | |||
2564 | void ELFDumper<ELFT>::printGnuHashTable() { | |||
2565 | DictScope D(W, "GnuHashTable"); | |||
2566 | if (!GnuHashTable) | |||
2567 | return; | |||
2568 | ||||
2569 | bool IsHeaderValid; | |||
2570 | Error Err = checkGNUHashTable<ELFT>(Obj, GnuHashTable, &IsHeaderValid); | |||
2571 | if (IsHeaderValid) { | |||
2572 | W.printNumber("Num Buckets", GnuHashTable->nbuckets); | |||
2573 | W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); | |||
2574 | W.printNumber("Num Mask Words", GnuHashTable->maskwords); | |||
2575 | W.printNumber("Shift Count", GnuHashTable->shift2); | |||
2576 | } | |||
2577 | ||||
2578 | if (Err) { | |||
2579 | reportUniqueWarning(std::move(Err)); | |||
2580 | return; | |||
2581 | } | |||
2582 | ||||
2583 | ArrayRef<typename ELFT::Off> BloomFilter = GnuHashTable->filter(); | |||
2584 | W.printHexList("Bloom Filter", BloomFilter); | |||
2585 | ||||
2586 | ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets(); | |||
2587 | W.printList("Buckets", Buckets); | |||
2588 | ||||
2589 | Expected<ArrayRef<Elf_Word>> Chains = | |||
2590 | getGnuHashTableChains<ELFT>(DynSymRegion, GnuHashTable); | |||
2591 | if (!Chains) { | |||
2592 | reportUniqueWarning("unable to dump 'Values' for the SHT_GNU_HASH " | |||
2593 | "section: " + | |||
2594 | toString(Chains.takeError())); | |||
2595 | return; | |||
2596 | } | |||
2597 | ||||
2598 | W.printHexList("Values", *Chains); | |||
2599 | } | |||
2600 | ||||
2601 | template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { | |||
2602 | StringRef SOName = "<Not found>"; | |||
2603 | if (SONameOffset) | |||
2604 | SOName = getDynamicString(*SONameOffset); | |||
2605 | W.printString("LoadName", SOName); | |||
2606 | } | |||
2607 | ||||
2608 | template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() { | |||
2609 | switch (Obj.getHeader().e_machine) { | |||
2610 | case EM_ARM: | |||
2611 | if (Obj.isLE()) | |||
2612 | printAttributes(ELF::SHT_ARM_ATTRIBUTES, | |||
2613 | std::make_unique<ARMAttributeParser>(&W), | |||
2614 | support::little); | |||
2615 | else | |||
2616 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2617 | "ARM objects"); | |||
2618 | break; | |||
2619 | case EM_RISCV: | |||
2620 | if (Obj.isLE()) | |||
2621 | printAttributes(ELF::SHT_RISCV_ATTRIBUTES, | |||
2622 | std::make_unique<RISCVAttributeParser>(&W), | |||
2623 | support::little); | |||
2624 | else | |||
2625 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2626 | "RISC-V objects"); | |||
2627 | break; | |||
2628 | case EM_MSP430: | |||
2629 | printAttributes(ELF::SHT_MSP430_ATTRIBUTES, | |||
2630 | std::make_unique<MSP430AttributeParser>(&W), | |||
2631 | support::little); | |||
2632 | break; | |||
2633 | case EM_MIPS: { | |||
2634 | printMipsABIFlags(); | |||
2635 | printMipsOptions(); | |||
2636 | printMipsReginfo(); | |||
2637 | MipsGOTParser<ELFT> Parser(*this); | |||
2638 | if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols())) | |||
2639 | reportUniqueWarning(std::move(E)); | |||
2640 | else if (!Parser.isGotEmpty()) | |||
2641 | printMipsGOT(Parser); | |||
2642 | ||||
2643 | if (Error E = Parser.findPLT(dynamic_table())) | |||
2644 | reportUniqueWarning(std::move(E)); | |||
2645 | else if (!Parser.isPltEmpty()) | |||
2646 | printMipsPLT(Parser); | |||
2647 | break; | |||
2648 | } | |||
2649 | default: | |||
2650 | break; | |||
2651 | } | |||
2652 | } | |||
2653 | ||||
2654 | template <class ELFT> | |||
2655 | void ELFDumper<ELFT>::printAttributes( | |||
2656 | unsigned AttrShType, std::unique_ptr<ELFAttributeParser> AttrParser, | |||
2657 | support::endianness Endianness) { | |||
2658 | assert((AttrShType != ELF::SHT_NULL) && AttrParser &&(static_cast <bool> ((AttrShType != ELF::SHT_NULL) && AttrParser && "Incomplete ELF attribute implementation" ) ? void (0) : __assert_fail ("(AttrShType != ELF::SHT_NULL) && AttrParser && \"Incomplete ELF attribute implementation\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 2659, __extension__ __PRETTY_FUNCTION__)) | |||
2659 | "Incomplete ELF attribute implementation")(static_cast <bool> ((AttrShType != ELF::SHT_NULL) && AttrParser && "Incomplete ELF attribute implementation" ) ? void (0) : __assert_fail ("(AttrShType != ELF::SHT_NULL) && AttrParser && \"Incomplete ELF attribute implementation\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 2659, __extension__ __PRETTY_FUNCTION__)); | |||
2660 | DictScope BA(W, "BuildAttributes"); | |||
2661 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
2662 | if (Sec.sh_type != AttrShType) | |||
2663 | continue; | |||
2664 | ||||
2665 | ArrayRef<uint8_t> Contents; | |||
2666 | if (Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
2667 | Obj.getSectionContents(Sec)) { | |||
2668 | Contents = *ContentOrErr; | |||
2669 | if (Contents.empty()) { | |||
2670 | reportUniqueWarning("the " + describe(Sec) + " is empty"); | |||
2671 | continue; | |||
2672 | } | |||
2673 | } else { | |||
2674 | reportUniqueWarning("unable to read the content of the " + describe(Sec) + | |||
2675 | ": " + toString(ContentOrErr.takeError())); | |||
2676 | continue; | |||
2677 | } | |||
2678 | ||||
2679 | W.printHex("FormatVersion", Contents[0]); | |||
2680 | ||||
2681 | if (Error E = AttrParser->parse(Contents, Endianness)) | |||
2682 | reportUniqueWarning("unable to dump attributes from the " + | |||
2683 | describe(Sec) + ": " + toString(std::move(E))); | |||
2684 | } | |||
2685 | } | |||
2686 | ||||
2687 | namespace { | |||
2688 | ||||
2689 | template <class ELFT> class MipsGOTParser { | |||
2690 | public: | |||
2691 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_Nhdr = typename ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator = typename ELFT::NoteIterator ; using Elf_CGProfile = typename ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Shdr_Range = typename ELFT ::ShdrRange; using Elf_Sym_Range = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using Elf_Relr_Range = typename ELFT ::RelrRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; | |||
2692 | using Entry = typename ELFT::Addr; | |||
2693 | using Entries = ArrayRef<Entry>; | |||
2694 | ||||
2695 | const bool IsStatic; | |||
2696 | const ELFFile<ELFT> &Obj; | |||
2697 | const ELFDumper<ELFT> &Dumper; | |||
2698 | ||||
2699 | MipsGOTParser(const ELFDumper<ELFT> &D); | |||
2700 | Error findGOT(Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms); | |||
2701 | Error findPLT(Elf_Dyn_Range DynTable); | |||
2702 | ||||
2703 | bool isGotEmpty() const { return GotEntries.empty(); } | |||
2704 | bool isPltEmpty() const { return PltEntries.empty(); } | |||
2705 | ||||
2706 | uint64_t getGp() const; | |||
2707 | ||||
2708 | const Entry *getGotLazyResolver() const; | |||
2709 | const Entry *getGotModulePointer() const; | |||
2710 | const Entry *getPltLazyResolver() const; | |||
2711 | const Entry *getPltModulePointer() const; | |||
2712 | ||||
2713 | Entries getLocalEntries() const; | |||
2714 | Entries getGlobalEntries() const; | |||
2715 | Entries getOtherEntries() const; | |||
2716 | Entries getPltEntries() const; | |||
2717 | ||||
2718 | uint64_t getGotAddress(const Entry * E) const; | |||
2719 | int64_t getGotOffset(const Entry * E) const; | |||
2720 | const Elf_Sym *getGotSym(const Entry *E) const; | |||
2721 | ||||
2722 | uint64_t getPltAddress(const Entry * E) const; | |||
2723 | const Elf_Sym *getPltSym(const Entry *E) const; | |||
2724 | ||||
2725 | StringRef getPltStrTable() const { return PltStrTable; } | |||
2726 | const Elf_Shdr *getPltSymTable() const { return PltSymTable; } | |||
2727 | ||||
2728 | private: | |||
2729 | const Elf_Shdr *GotSec; | |||
2730 | size_t LocalNum; | |||
2731 | size_t GlobalNum; | |||
2732 | ||||
2733 | const Elf_Shdr *PltSec; | |||
2734 | const Elf_Shdr *PltRelSec; | |||
2735 | const Elf_Shdr *PltSymTable; | |||
2736 | StringRef FileName; | |||
2737 | ||||
2738 | Elf_Sym_Range GotDynSyms; | |||
2739 | StringRef PltStrTable; | |||
2740 | ||||
2741 | Entries GotEntries; | |||
2742 | Entries PltEntries; | |||
2743 | }; | |||
2744 | ||||
2745 | } // end anonymous namespace | |||
2746 | ||||
2747 | template <class ELFT> | |||
2748 | MipsGOTParser<ELFT>::MipsGOTParser(const ELFDumper<ELFT> &D) | |||
2749 | : IsStatic(D.dynamic_table().empty()), Obj(D.getElfObject().getELFFile()), | |||
2750 | Dumper(D), GotSec(nullptr), LocalNum(0), GlobalNum(0), PltSec(nullptr), | |||
2751 | PltRelSec(nullptr), PltSymTable(nullptr), | |||
2752 | FileName(D.getElfObject().getFileName()) {} | |||
2753 | ||||
2754 | template <class ELFT> | |||
2755 | Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable, | |||
2756 | Elf_Sym_Range DynSyms) { | |||
2757 | // See "Global Offset Table" in Chapter 5 in the following document | |||
2758 | // for detailed GOT description. | |||
2759 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
2760 | ||||
2761 | // Find static GOT secton. | |||
2762 | if (IsStatic) { | |||
2763 | GotSec = Dumper.findSectionByName(".got"); | |||
2764 | if (!GotSec) | |||
2765 | return Error::success(); | |||
2766 | ||||
2767 | ArrayRef<uint8_t> Content = | |||
2768 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
2769 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
2770 | Content.size() / sizeof(Entry)); | |||
2771 | LocalNum = GotEntries.size(); | |||
2772 | return Error::success(); | |||
2773 | } | |||
2774 | ||||
2775 | // Lookup dynamic table tags which define the GOT layout. | |||
2776 | Optional<uint64_t> DtPltGot; | |||
2777 | Optional<uint64_t> DtLocalGotNum; | |||
2778 | Optional<uint64_t> DtGotSym; | |||
2779 | for (const auto &Entry : DynTable) { | |||
2780 | switch (Entry.getTag()) { | |||
2781 | case ELF::DT_PLTGOT: | |||
2782 | DtPltGot = Entry.getVal(); | |||
2783 | break; | |||
2784 | case ELF::DT_MIPS_LOCAL_GOTNO: | |||
2785 | DtLocalGotNum = Entry.getVal(); | |||
2786 | break; | |||
2787 | case ELF::DT_MIPS_GOTSYM: | |||
2788 | DtGotSym = Entry.getVal(); | |||
2789 | break; | |||
2790 | } | |||
2791 | } | |||
2792 | ||||
2793 | if (!DtPltGot && !DtLocalGotNum && !DtGotSym) | |||
2794 | return Error::success(); | |||
2795 | ||||
2796 | if (!DtPltGot) | |||
2797 | return createError("cannot find PLTGOT dynamic tag"); | |||
2798 | if (!DtLocalGotNum) | |||
2799 | return createError("cannot find MIPS_LOCAL_GOTNO dynamic tag"); | |||
2800 | if (!DtGotSym) | |||
2801 | return createError("cannot find MIPS_GOTSYM dynamic tag"); | |||
2802 | ||||
2803 | size_t DynSymTotal = DynSyms.size(); | |||
2804 | if (*DtGotSym > DynSymTotal) | |||
2805 | return createError("DT_MIPS_GOTSYM value (" + Twine(*DtGotSym) + | |||
2806 | ") exceeds the number of dynamic symbols (" + | |||
2807 | Twine(DynSymTotal) + ")"); | |||
2808 | ||||
2809 | GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot); | |||
2810 | if (!GotSec) | |||
2811 | return createError("there is no non-empty GOT section at 0x" + | |||
2812 | Twine::utohexstr(*DtPltGot)); | |||
2813 | ||||
2814 | LocalNum = *DtLocalGotNum; | |||
2815 | GlobalNum = DynSymTotal - *DtGotSym; | |||
2816 | ||||
2817 | ArrayRef<uint8_t> Content = | |||
2818 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
2819 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
2820 | Content.size() / sizeof(Entry)); | |||
2821 | GotDynSyms = DynSyms.drop_front(*DtGotSym); | |||
2822 | ||||
2823 | return Error::success(); | |||
2824 | } | |||
2825 | ||||
2826 | template <class ELFT> | |||
2827 | Error MipsGOTParser<ELFT>::findPLT(Elf_Dyn_Range DynTable) { | |||
2828 | // Lookup dynamic table tags which define the PLT layout. | |||
2829 | Optional<uint64_t> DtMipsPltGot; | |||
2830 | Optional<uint64_t> DtJmpRel; | |||
2831 | for (const auto &Entry : DynTable) { | |||
2832 | switch (Entry.getTag()) { | |||
2833 | case ELF::DT_MIPS_PLTGOT: | |||
2834 | DtMipsPltGot = Entry.getVal(); | |||
2835 | break; | |||
2836 | case ELF::DT_JMPREL: | |||
2837 | DtJmpRel = Entry.getVal(); | |||
2838 | break; | |||
2839 | } | |||
2840 | } | |||
2841 | ||||
2842 | if (!DtMipsPltGot && !DtJmpRel) | |||
2843 | return Error::success(); | |||
2844 | ||||
2845 | // Find PLT section. | |||
2846 | if (!DtMipsPltGot) | |||
2847 | return createError("cannot find MIPS_PLTGOT dynamic tag"); | |||
2848 | if (!DtJmpRel) | |||
2849 | return createError("cannot find JMPREL dynamic tag"); | |||
2850 | ||||
2851 | PltSec = findNotEmptySectionByAddress(Obj, FileName, *DtMipsPltGot); | |||
2852 | if (!PltSec) | |||
2853 | return createError("there is no non-empty PLTGOT section at 0x" + | |||
2854 | Twine::utohexstr(*DtMipsPltGot)); | |||
2855 | ||||
2856 | PltRelSec = findNotEmptySectionByAddress(Obj, FileName, *DtJmpRel); | |||
2857 | if (!PltRelSec) | |||
2858 | return createError("there is no non-empty RELPLT section at 0x" + | |||
2859 | Twine::utohexstr(*DtJmpRel)); | |||
2860 | ||||
2861 | if (Expected<ArrayRef<uint8_t>> PltContentOrErr = | |||
2862 | Obj.getSectionContents(*PltSec)) | |||
2863 | PltEntries = | |||
2864 | Entries(reinterpret_cast<const Entry *>(PltContentOrErr->data()), | |||
2865 | PltContentOrErr->size() / sizeof(Entry)); | |||
2866 | else | |||
2867 | return createError("unable to read PLTGOT section content: " + | |||
2868 | toString(PltContentOrErr.takeError())); | |||
2869 | ||||
2870 | if (Expected<const Elf_Shdr *> PltSymTableOrErr = | |||
2871 | Obj.getSection(PltRelSec->sh_link)) | |||
2872 | PltSymTable = *PltSymTableOrErr; | |||
2873 | else | |||
2874 | return createError("unable to get a symbol table linked to the " + | |||
2875 | describe(Obj, *PltRelSec) + ": " + | |||
2876 | toString(PltSymTableOrErr.takeError())); | |||
2877 | ||||
2878 | if (Expected<StringRef> StrTabOrErr = | |||
2879 | Obj.getStringTableForSymtab(*PltSymTable)) | |||
2880 | PltStrTable = *StrTabOrErr; | |||
2881 | else | |||
2882 | return createError("unable to get a string table for the " + | |||
2883 | describe(Obj, *PltSymTable) + ": " + | |||
2884 | toString(StrTabOrErr.takeError())); | |||
2885 | ||||
2886 | return Error::success(); | |||
2887 | } | |||
2888 | ||||
2889 | template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const { | |||
2890 | return GotSec->sh_addr + 0x7ff0; | |||
2891 | } | |||
2892 | ||||
2893 | template <class ELFT> | |||
2894 | const typename MipsGOTParser<ELFT>::Entry * | |||
2895 | MipsGOTParser<ELFT>::getGotLazyResolver() const { | |||
2896 | return LocalNum > 0 ? &GotEntries[0] : nullptr; | |||
2897 | } | |||
2898 | ||||
2899 | template <class ELFT> | |||
2900 | const typename MipsGOTParser<ELFT>::Entry * | |||
2901 | MipsGOTParser<ELFT>::getGotModulePointer() const { | |||
2902 | if (LocalNum < 2) | |||
2903 | return nullptr; | |||
2904 | const Entry &E = GotEntries[1]; | |||
2905 | if ((E >> (sizeof(Entry) * 8 - 1)) == 0) | |||
2906 | return nullptr; | |||
2907 | return &E; | |||
2908 | } | |||
2909 | ||||
2910 | template <class ELFT> | |||
2911 | typename MipsGOTParser<ELFT>::Entries | |||
2912 | MipsGOTParser<ELFT>::getLocalEntries() const { | |||
2913 | size_t Skip = getGotModulePointer() ? 2 : 1; | |||
2914 | if (LocalNum - Skip <= 0) | |||
2915 | return Entries(); | |||
2916 | return GotEntries.slice(Skip, LocalNum - Skip); | |||
2917 | } | |||
2918 | ||||
2919 | template <class ELFT> | |||
2920 | typename MipsGOTParser<ELFT>::Entries | |||
2921 | MipsGOTParser<ELFT>::getGlobalEntries() const { | |||
2922 | if (GlobalNum == 0) | |||
2923 | return Entries(); | |||
2924 | return GotEntries.slice(LocalNum, GlobalNum); | |||
2925 | } | |||
2926 | ||||
2927 | template <class ELFT> | |||
2928 | typename MipsGOTParser<ELFT>::Entries | |||
2929 | MipsGOTParser<ELFT>::getOtherEntries() const { | |||
2930 | size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum; | |||
2931 | if (OtherNum == 0) | |||
2932 | return Entries(); | |||
2933 | return GotEntries.slice(LocalNum + GlobalNum, OtherNum); | |||
2934 | } | |||
2935 | ||||
2936 | template <class ELFT> | |||
2937 | uint64_t MipsGOTParser<ELFT>::getGotAddress(const Entry *E) const { | |||
2938 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
2939 | return GotSec->sh_addr + Offset; | |||
2940 | } | |||
2941 | ||||
2942 | template <class ELFT> | |||
2943 | int64_t MipsGOTParser<ELFT>::getGotOffset(const Entry *E) const { | |||
2944 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
2945 | return Offset - 0x7ff0; | |||
2946 | } | |||
2947 | ||||
2948 | template <class ELFT> | |||
2949 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
2950 | MipsGOTParser<ELFT>::getGotSym(const Entry *E) const { | |||
2951 | int64_t Offset = std::distance(GotEntries.data(), E); | |||
2952 | return &GotDynSyms[Offset - LocalNum]; | |||
2953 | } | |||
2954 | ||||
2955 | template <class ELFT> | |||
2956 | const typename MipsGOTParser<ELFT>::Entry * | |||
2957 | MipsGOTParser<ELFT>::getPltLazyResolver() const { | |||
2958 | return PltEntries.empty() ? nullptr : &PltEntries[0]; | |||
2959 | } | |||
2960 | ||||
2961 | template <class ELFT> | |||
2962 | const typename MipsGOTParser<ELFT>::Entry * | |||
2963 | MipsGOTParser<ELFT>::getPltModulePointer() const { | |||
2964 | return PltEntries.size() < 2 ? nullptr : &PltEntries[1]; | |||
2965 | } | |||
2966 | ||||
2967 | template <class ELFT> | |||
2968 | typename MipsGOTParser<ELFT>::Entries | |||
2969 | MipsGOTParser<ELFT>::getPltEntries() const { | |||
2970 | if (PltEntries.size() <= 2) | |||
2971 | return Entries(); | |||
2972 | return PltEntries.slice(2, PltEntries.size() - 2); | |||
2973 | } | |||
2974 | ||||
2975 | template <class ELFT> | |||
2976 | uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const { | |||
2977 | int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry); | |||
2978 | return PltSec->sh_addr + Offset; | |||
2979 | } | |||
2980 | ||||
2981 | template <class ELFT> | |||
2982 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
2983 | MipsGOTParser<ELFT>::getPltSym(const Entry *E) const { | |||
2984 | int64_t Offset = std::distance(getPltEntries().data(), E); | |||
2985 | if (PltRelSec->sh_type == ELF::SHT_REL) { | |||
2986 | Elf_Rel_Range Rels = unwrapOrError(FileName, Obj.rels(*PltRelSec)); | |||
2987 | return unwrapOrError(FileName, | |||
2988 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
2989 | } else { | |||
2990 | Elf_Rela_Range Rels = unwrapOrError(FileName, Obj.relas(*PltRelSec)); | |||
2991 | return unwrapOrError(FileName, | |||
2992 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
2993 | } | |||
2994 | } | |||
2995 | ||||
2996 | const EnumEntry<unsigned> ElfMipsISAExtType[] = { | |||
2997 | {"None", Mips::AFL_EXT_NONE}, | |||
2998 | {"Broadcom SB-1", Mips::AFL_EXT_SB1}, | |||
2999 | {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, | |||
3000 | {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, | |||
3001 | {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, | |||
3002 | {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, | |||
3003 | {"LSI R4010", Mips::AFL_EXT_4010}, | |||
3004 | {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, | |||
3005 | {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, | |||
3006 | {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, | |||
3007 | {"MIPS R4650", Mips::AFL_EXT_4650}, | |||
3008 | {"MIPS R5900", Mips::AFL_EXT_5900}, | |||
3009 | {"MIPS R10000", Mips::AFL_EXT_10000}, | |||
3010 | {"NEC VR4100", Mips::AFL_EXT_4100}, | |||
3011 | {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, | |||
3012 | {"NEC VR4120", Mips::AFL_EXT_4120}, | |||
3013 | {"NEC VR5400", Mips::AFL_EXT_5400}, | |||
3014 | {"NEC VR5500", Mips::AFL_EXT_5500}, | |||
3015 | {"RMI Xlr", Mips::AFL_EXT_XLR}, | |||
3016 | {"Toshiba R3900", Mips::AFL_EXT_3900} | |||
3017 | }; | |||
3018 | ||||
3019 | const EnumEntry<unsigned> ElfMipsASEFlags[] = { | |||
3020 | {"DSP", Mips::AFL_ASE_DSP}, | |||
3021 | {"DSPR2", Mips::AFL_ASE_DSPR2}, | |||
3022 | {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, | |||
3023 | {"MCU", Mips::AFL_ASE_MCU}, | |||
3024 | {"MDMX", Mips::AFL_ASE_MDMX}, | |||
3025 | {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, | |||
3026 | {"MT", Mips::AFL_ASE_MT}, | |||
3027 | {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, | |||
3028 | {"VZ", Mips::AFL_ASE_VIRT}, | |||
3029 | {"MSA", Mips::AFL_ASE_MSA}, | |||
3030 | {"MIPS16", Mips::AFL_ASE_MIPS16}, | |||
3031 | {"microMIPS", Mips::AFL_ASE_MICROMIPS}, | |||
3032 | {"XPA", Mips::AFL_ASE_XPA}, | |||
3033 | {"CRC", Mips::AFL_ASE_CRC}, | |||
3034 | {"GINV", Mips::AFL_ASE_GINV}, | |||
3035 | }; | |||
3036 | ||||
3037 | const EnumEntry<unsigned> ElfMipsFpABIType[] = { | |||
3038 | {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, | |||
3039 | {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, | |||
3040 | {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, | |||
3041 | {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, | |||
3042 | {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", | |||
3043 | Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, | |||
3044 | {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, | |||
3045 | {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, | |||
3046 | {"Hard float compat (32-bit CPU, 64-bit FPU)", | |||
3047 | Mips::Val_GNU_MIPS_ABI_FP_64A} | |||
3048 | }; | |||
3049 | ||||
3050 | static const EnumEntry<unsigned> ElfMipsFlags1[] { | |||
3051 | {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, | |||
3052 | }; | |||
3053 | ||||
3054 | static int getMipsRegisterSize(uint8_t Flag) { | |||
3055 | switch (Flag) { | |||
3056 | case Mips::AFL_REG_NONE: | |||
3057 | return 0; | |||
3058 | case Mips::AFL_REG_32: | |||
3059 | return 32; | |||
3060 | case Mips::AFL_REG_64: | |||
3061 | return 64; | |||
3062 | case Mips::AFL_REG_128: | |||
3063 | return 128; | |||
3064 | default: | |||
3065 | return -1; | |||
3066 | } | |||
3067 | } | |||
3068 | ||||
3069 | template <class ELFT> | |||
3070 | static void printMipsReginfoData(ScopedPrinter &W, | |||
3071 | const Elf_Mips_RegInfo<ELFT> &Reginfo) { | |||
3072 | W.printHex("GP", Reginfo.ri_gp_value); | |||
3073 | W.printHex("General Mask", Reginfo.ri_gprmask); | |||
3074 | W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); | |||
3075 | W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); | |||
3076 | W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); | |||
3077 | W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); | |||
3078 | } | |||
3079 | ||||
3080 | template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { | |||
3081 | const Elf_Shdr *RegInfoSec = findSectionByName(".reginfo"); | |||
3082 | if (!RegInfoSec) { | |||
3083 | W.startLine() << "There is no .reginfo section in the file.\n"; | |||
3084 | return; | |||
3085 | } | |||
3086 | ||||
3087 | Expected<ArrayRef<uint8_t>> ContentsOrErr = | |||
3088 | Obj.getSectionContents(*RegInfoSec); | |||
3089 | if (!ContentsOrErr) { | |||
3090 | this->reportUniqueWarning( | |||
3091 | "unable to read the content of the .reginfo section (" + | |||
3092 | describe(*RegInfoSec) + "): " + toString(ContentsOrErr.takeError())); | |||
3093 | return; | |||
3094 | } | |||
3095 | ||||
3096 | if (ContentsOrErr->size() < sizeof(Elf_Mips_RegInfo<ELFT>)) { | |||
3097 | this->reportUniqueWarning("the .reginfo section has an invalid size (0x" + | |||
3098 | Twine::utohexstr(ContentsOrErr->size()) + ")"); | |||
3099 | return; | |||
3100 | } | |||
3101 | ||||
3102 | DictScope GS(W, "MIPS RegInfo"); | |||
3103 | printMipsReginfoData(W, *reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>( | |||
3104 | ContentsOrErr->data())); | |||
3105 | } | |||
3106 | ||||
3107 | template <class ELFT> | |||
3108 | static Expected<const Elf_Mips_Options<ELFT> *> | |||
3109 | readMipsOptions(const uint8_t *SecBegin, ArrayRef<uint8_t> &SecData, | |||
3110 | bool &IsSupported) { | |||
3111 | if (SecData.size() < sizeof(Elf_Mips_Options<ELFT>)) | |||
3112 | return createError("the .MIPS.options section has an invalid size (0x" + | |||
3113 | Twine::utohexstr(SecData.size()) + ")"); | |||
3114 | ||||
3115 | const Elf_Mips_Options<ELFT> *O = | |||
3116 | reinterpret_cast<const Elf_Mips_Options<ELFT> *>(SecData.data()); | |||
3117 | const uint8_t Size = O->size; | |||
3118 | if (Size > SecData.size()) { | |||
3119 | const uint64_t Offset = SecData.data() - SecBegin; | |||
3120 | const uint64_t SecSize = Offset + SecData.size(); | |||
3121 | return createError("a descriptor of size 0x" + Twine::utohexstr(Size) + | |||
3122 | " at offset 0x" + Twine::utohexstr(Offset) + | |||
3123 | " goes past the end of the .MIPS.options " | |||
3124 | "section of size 0x" + | |||
3125 | Twine::utohexstr(SecSize)); | |||
3126 | } | |||
3127 | ||||
3128 | IsSupported = O->kind == ODK_REGINFO; | |||
3129 | const size_t ExpectedSize = | |||
3130 | sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>); | |||
3131 | ||||
3132 | if (IsSupported) | |||
3133 | if (Size < ExpectedSize) | |||
3134 | return createError( | |||
3135 | "a .MIPS.options entry of kind " + | |||
3136 | Twine(getElfMipsOptionsOdkType(O->kind)) + | |||
3137 | " has an invalid size (0x" + Twine::utohexstr(Size) + | |||
3138 | "), the expected size is 0x" + Twine::utohexstr(ExpectedSize)); | |||
3139 | ||||
3140 | SecData = SecData.drop_front(Size); | |||
3141 | return O; | |||
3142 | } | |||
3143 | ||||
3144 | template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() { | |||
3145 | const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options"); | |||
3146 | if (!MipsOpts) { | |||
3147 | W.startLine() << "There is no .MIPS.options section in the file.\n"; | |||
3148 | return; | |||
3149 | } | |||
3150 | ||||
3151 | DictScope GS(W, "MIPS Options"); | |||
3152 | ||||
3153 | ArrayRef<uint8_t> Data = | |||
3154 | unwrapOrError(ObjF.getFileName(), Obj.getSectionContents(*MipsOpts)); | |||
3155 | const uint8_t *const SecBegin = Data.begin(); | |||
3156 | while (!Data.empty()) { | |||
3157 | bool IsSupported; | |||
3158 | Expected<const Elf_Mips_Options<ELFT> *> OptsOrErr = | |||
3159 | readMipsOptions<ELFT>(SecBegin, Data, IsSupported); | |||
3160 | if (!OptsOrErr) { | |||
3161 | reportUniqueWarning(OptsOrErr.takeError()); | |||
3162 | break; | |||
3163 | } | |||
3164 | ||||
3165 | unsigned Kind = (*OptsOrErr)->kind; | |||
3166 | const char *Type = getElfMipsOptionsOdkType(Kind); | |||
3167 | if (!IsSupported) { | |||
3168 | W.startLine() << "Unsupported MIPS options tag: " << Type << " (" << Kind | |||
3169 | << ")\n"; | |||
3170 | continue; | |||
3171 | } | |||
3172 | ||||
3173 | DictScope GS(W, Type); | |||
3174 | if (Kind == ODK_REGINFO) | |||
3175 | printMipsReginfoData(W, (*OptsOrErr)->getRegInfo()); | |||
3176 | else | |||
3177 | llvm_unreachable("unexpected .MIPS.options section descriptor kind")::llvm::llvm_unreachable_internal("unexpected .MIPS.options section descriptor kind" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3177); | |||
3178 | } | |||
3179 | } | |||
3180 | ||||
3181 | template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { | |||
3182 | const Elf_Shdr *StackMapSection = findSectionByName(".llvm_stackmaps"); | |||
3183 | if (!StackMapSection) | |||
3184 | return; | |||
3185 | ||||
3186 | auto Warn = [&](Error &&E) { | |||
3187 | this->reportUniqueWarning("unable to read the stack map from " + | |||
3188 | describe(*StackMapSection) + ": " + | |||
3189 | toString(std::move(E))); | |||
3190 | }; | |||
3191 | ||||
3192 | Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
3193 | Obj.getSectionContents(*StackMapSection); | |||
3194 | if (!ContentOrErr) { | |||
3195 | Warn(ContentOrErr.takeError()); | |||
3196 | return; | |||
3197 | } | |||
3198 | ||||
3199 | if (Error E = StackMapParser<ELFT::TargetEndianness>::validateHeader( | |||
3200 | *ContentOrErr)) { | |||
3201 | Warn(std::move(E)); | |||
3202 | return; | |||
3203 | } | |||
3204 | ||||
3205 | prettyPrintStackMap(W, StackMapParser<ELFT::TargetEndianness>(*ContentOrErr)); | |||
3206 | } | |||
3207 | ||||
3208 | template <class ELFT> | |||
3209 | void ELFDumper<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
3210 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab) { | |||
3211 | Expected<RelSymbol<ELFT>> Target = getRelocationTarget(R, SymTab); | |||
3212 | if (!Target) | |||
3213 | reportUniqueWarning("unable to print relocation " + Twine(RelIndex) + | |||
3214 | " in " + describe(Sec) + ": " + | |||
3215 | toString(Target.takeError())); | |||
3216 | else | |||
3217 | printRelRelaReloc(R, *Target); | |||
3218 | } | |||
3219 | ||||
3220 | static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, | |||
3221 | StringRef Str2) { | |||
3222 | OS.PadToColumn(2u); | |||
3223 | OS << Str1; | |||
3224 | OS.PadToColumn(37u); | |||
3225 | OS << Str2 << "\n"; | |||
3226 | OS.flush(); | |||
3227 | } | |||
3228 | ||||
3229 | template <class ELFT> | |||
3230 | static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj, | |||
3231 | StringRef FileName) { | |||
3232 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3233 | if (ElfHeader.e_shnum != 0) | |||
3234 | return to_string(ElfHeader.e_shnum); | |||
3235 | ||||
3236 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3237 | if (!ArrOrErr) { | |||
3238 | // In this case we can ignore an error, because we have already reported a | |||
3239 | // warning about the broken section header table earlier. | |||
3240 | consumeError(ArrOrErr.takeError()); | |||
3241 | return "<?>"; | |||
3242 | } | |||
3243 | ||||
3244 | if (ArrOrErr->empty()) | |||
3245 | return "0"; | |||
3246 | return "0 (" + to_string((*ArrOrErr)[0].sh_size) + ")"; | |||
3247 | } | |||
3248 | ||||
3249 | template <class ELFT> | |||
3250 | static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> &Obj, | |||
3251 | StringRef FileName) { | |||
3252 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3253 | if (ElfHeader.e_shstrndx != SHN_XINDEX) | |||
3254 | return to_string(ElfHeader.e_shstrndx); | |||
3255 | ||||
3256 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3257 | if (!ArrOrErr) { | |||
3258 | // In this case we can ignore an error, because we have already reported a | |||
3259 | // warning about the broken section header table earlier. | |||
3260 | consumeError(ArrOrErr.takeError()); | |||
3261 | return "<?>"; | |||
3262 | } | |||
3263 | ||||
3264 | if (ArrOrErr->empty()) | |||
3265 | return "65535 (corrupt: out of range)"; | |||
3266 | return to_string(ElfHeader.e_shstrndx) + " (" + | |||
3267 | to_string((*ArrOrErr)[0].sh_link) + ")"; | |||
3268 | } | |||
3269 | ||||
3270 | static const EnumEntry<unsigned> *getObjectFileEnumEntry(unsigned Type) { | |||
3271 | auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) { | |||
3272 | return E.Value == Type; | |||
3273 | }); | |||
3274 | if (It != makeArrayRef(ElfObjectFileType).end()) | |||
3275 | return It; | |||
3276 | return nullptr; | |||
3277 | } | |||
3278 | ||||
3279 | template <class ELFT> | |||
3280 | void GNUELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
3281 | ArrayRef<std::string> InputFilenames, | |||
3282 | const Archive *A) { | |||
3283 | if (InputFilenames.size() > 1 || A) { | |||
3284 | this->W.startLine() << "\n"; | |||
3285 | this->W.printString("File", FileStr); | |||
3286 | } | |||
3287 | } | |||
3288 | ||||
3289 | template <class ELFT> void GNUELFDumper<ELFT>::printFileHeaders() { | |||
3290 | const Elf_Ehdr &e = this->Obj.getHeader(); | |||
3291 | OS << "ELF Header:\n"; | |||
3292 | OS << " Magic: "; | |||
3293 | std::string Str; | |||
3294 | for (int i = 0; i < ELF::EI_NIDENT; i++) | |||
3295 | OS << format(" %02x", static_cast<int>(e.e_ident[i])); | |||
3296 | OS << "\n"; | |||
3297 | Str = enumToString(e.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); | |||
3298 | printFields(OS, "Class:", Str); | |||
3299 | Str = enumToString(e.e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); | |||
3300 | printFields(OS, "Data:", Str); | |||
3301 | OS.PadToColumn(2u); | |||
3302 | OS << "Version:"; | |||
3303 | OS.PadToColumn(37u); | |||
3304 | OS << to_hexString(e.e_ident[ELF::EI_VERSION]); | |||
3305 | if (e.e_version == ELF::EV_CURRENT) | |||
3306 | OS << " (current)"; | |||
3307 | OS << "\n"; | |||
3308 | Str = enumToString(e.e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); | |||
3309 | printFields(OS, "OS/ABI:", Str); | |||
3310 | printFields(OS, | |||
3311 | "ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION])); | |||
3312 | ||||
3313 | if (const EnumEntry<unsigned> *E = getObjectFileEnumEntry(e.e_type)) { | |||
3314 | Str = E->AltName.str(); | |||
3315 | } else { | |||
3316 | if (e.e_type >= ET_LOPROC) | |||
3317 | Str = "Processor Specific: (" + to_hexString(e.e_type, false) + ")"; | |||
3318 | else if (e.e_type >= ET_LOOS) | |||
3319 | Str = "OS Specific: (" + to_hexString(e.e_type, false) + ")"; | |||
3320 | else | |||
3321 | Str = "<unknown>: " + to_hexString(e.e_type, false); | |||
3322 | } | |||
3323 | printFields(OS, "Type:", Str); | |||
3324 | ||||
3325 | Str = enumToString(e.e_machine, makeArrayRef(ElfMachineType)); | |||
3326 | printFields(OS, "Machine:", Str); | |||
3327 | Str = "0x" + to_hexString(e.e_version); | |||
3328 | printFields(OS, "Version:", Str); | |||
3329 | Str = "0x" + to_hexString(e.e_entry); | |||
3330 | printFields(OS, "Entry point address:", Str); | |||
3331 | Str = to_string(e.e_phoff) + " (bytes into file)"; | |||
3332 | printFields(OS, "Start of program headers:", Str); | |||
3333 | Str = to_string(e.e_shoff) + " (bytes into file)"; | |||
3334 | printFields(OS, "Start of section headers:", Str); | |||
3335 | std::string ElfFlags; | |||
3336 | if (e.e_machine == EM_MIPS) | |||
3337 | ElfFlags = | |||
3338 | printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags), | |||
3339 | unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), | |||
3340 | unsigned(ELF::EF_MIPS_MACH)); | |||
3341 | else if (e.e_machine == EM_RISCV) | |||
3342 | ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags)); | |||
3343 | else if (e.e_machine == EM_AVR) | |||
3344 | ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderAVRFlags), | |||
3345 | unsigned(ELF::EF_AVR_ARCH_MASK)); | |||
3346 | Str = "0x" + to_hexString(e.e_flags); | |||
3347 | if (!ElfFlags.empty()) | |||
3348 | Str = Str + ", " + ElfFlags; | |||
3349 | printFields(OS, "Flags:", Str); | |||
3350 | Str = to_string(e.e_ehsize) + " (bytes)"; | |||
3351 | printFields(OS, "Size of this header:", Str); | |||
3352 | Str = to_string(e.e_phentsize) + " (bytes)"; | |||
3353 | printFields(OS, "Size of program headers:", Str); | |||
3354 | Str = to_string(e.e_phnum); | |||
3355 | printFields(OS, "Number of program headers:", Str); | |||
3356 | Str = to_string(e.e_shentsize) + " (bytes)"; | |||
3357 | printFields(OS, "Size of section headers:", Str); | |||
3358 | Str = getSectionHeadersNumString(this->Obj, this->FileName); | |||
3359 | printFields(OS, "Number of section headers:", Str); | |||
3360 | Str = getSectionHeaderTableIndexString(this->Obj, this->FileName); | |||
3361 | printFields(OS, "Section header string table index:", Str); | |||
3362 | } | |||
3363 | ||||
3364 | template <class ELFT> std::vector<GroupSection> ELFDumper<ELFT>::getGroups() { | |||
3365 | auto GetSignature = [&](const Elf_Sym &Sym, unsigned SymNdx, | |||
3366 | const Elf_Shdr &Symtab) -> StringRef { | |||
3367 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(Symtab); | |||
3368 | if (!StrTableOrErr) { | |||
3369 | reportUniqueWarning("unable to get the string table for " + | |||
3370 | describe(Symtab) + ": " + | |||
3371 | toString(StrTableOrErr.takeError())); | |||
3372 | return "<?>"; | |||
3373 | } | |||
3374 | ||||
3375 | StringRef Strings = *StrTableOrErr; | |||
3376 | if (Sym.st_name >= Strings.size()) { | |||
3377 | reportUniqueWarning("unable to get the name of the symbol with index " + | |||
3378 | Twine(SymNdx) + ": st_name (0x" + | |||
3379 | Twine::utohexstr(Sym.st_name) + | |||
3380 | ") is past the end of the string table of size 0x" + | |||
3381 | Twine::utohexstr(Strings.size())); | |||
3382 | return "<?>"; | |||
3383 | } | |||
3384 | ||||
3385 | return StrTableOrErr->data() + Sym.st_name; | |||
3386 | }; | |||
3387 | ||||
3388 | std::vector<GroupSection> Ret; | |||
3389 | uint64_t I = 0; | |||
3390 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
3391 | ++I; | |||
3392 | if (Sec.sh_type != ELF::SHT_GROUP) | |||
3393 | continue; | |||
3394 | ||||
3395 | StringRef Signature = "<?>"; | |||
3396 | if (Expected<const Elf_Shdr *> SymtabOrErr = Obj.getSection(Sec.sh_link)) { | |||
3397 | if (Expected<const Elf_Sym *> SymOrErr = | |||
3398 | Obj.template getEntry<Elf_Sym>(**SymtabOrErr, Sec.sh_info)) | |||
3399 | Signature = GetSignature(**SymOrErr, Sec.sh_info, **SymtabOrErr); | |||
3400 | else | |||
3401 | reportUniqueWarning("unable to get the signature symbol for " + | |||
3402 | describe(Sec) + ": " + | |||
3403 | toString(SymOrErr.takeError())); | |||
3404 | } else { | |||
3405 | reportUniqueWarning("unable to get the symbol table for " + | |||
3406 | describe(Sec) + ": " + | |||
3407 | toString(SymtabOrErr.takeError())); | |||
3408 | } | |||
3409 | ||||
3410 | ArrayRef<Elf_Word> Data; | |||
3411 | if (Expected<ArrayRef<Elf_Word>> ContentsOrErr = | |||
3412 | Obj.template getSectionContentsAsArray<Elf_Word>(Sec)) { | |||
3413 | if (ContentsOrErr->empty()) | |||
3414 | reportUniqueWarning("unable to read the section group flag from the " + | |||
3415 | describe(Sec) + ": the section is empty"); | |||
3416 | else | |||
3417 | Data = *ContentsOrErr; | |||
3418 | } else { | |||
3419 | reportUniqueWarning("unable to get the content of the " + describe(Sec) + | |||
3420 | ": " + toString(ContentsOrErr.takeError())); | |||
3421 | } | |||
3422 | ||||
3423 | Ret.push_back({getPrintableSectionName(Sec), | |||
3424 | maybeDemangle(Signature), | |||
3425 | Sec.sh_name, | |||
3426 | I - 1, | |||
3427 | Sec.sh_link, | |||
3428 | Sec.sh_info, | |||
3429 | Data.empty() ? Elf_Word(0) : Data[0], | |||
3430 | {}}); | |||
3431 | ||||
3432 | if (Data.empty()) | |||
3433 | continue; | |||
3434 | ||||
3435 | std::vector<GroupMember> &GM = Ret.back().Members; | |||
3436 | for (uint32_t Ndx : Data.slice(1)) { | |||
3437 | if (Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(Ndx)) { | |||
3438 | GM.push_back({getPrintableSectionName(**SecOrErr), Ndx}); | |||
3439 | } else { | |||
3440 | reportUniqueWarning("unable to get the section with index " + | |||
3441 | Twine(Ndx) + " when dumping the " + describe(Sec) + | |||
3442 | ": " + toString(SecOrErr.takeError())); | |||
3443 | GM.push_back({"<?>", Ndx}); | |||
3444 | } | |||
3445 | } | |||
3446 | } | |||
3447 | return Ret; | |||
3448 | } | |||
3449 | ||||
3450 | static DenseMap<uint64_t, const GroupSection *> | |||
3451 | mapSectionsToGroups(ArrayRef<GroupSection> Groups) { | |||
3452 | DenseMap<uint64_t, const GroupSection *> Ret; | |||
3453 | for (const GroupSection &G : Groups) | |||
3454 | for (const GroupMember &GM : G.Members) | |||
3455 | Ret.insert({GM.Index, &G}); | |||
3456 | return Ret; | |||
3457 | } | |||
3458 | ||||
3459 | template <class ELFT> void GNUELFDumper<ELFT>::printGroupSections() { | |||
3460 | std::vector<GroupSection> V = this->getGroups(); | |||
3461 | DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); | |||
3462 | for (const GroupSection &G : V) { | |||
3463 | OS << "\n" | |||
3464 | << getGroupType(G.Type) << " group section [" | |||
3465 | << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature | |||
3466 | << "] contains " << G.Members.size() << " sections:\n" | |||
3467 | << " [Index] Name\n"; | |||
3468 | for (const GroupMember &GM : G.Members) { | |||
3469 | const GroupSection *MainGroup = Map[GM.Index]; | |||
3470 | if (MainGroup != &G) | |||
3471 | this->reportUniqueWarning( | |||
3472 | "section with index " + Twine(GM.Index) + | |||
3473 | ", included in the group section with index " + | |||
3474 | Twine(MainGroup->Index) + | |||
3475 | ", was also found in the group section with index " + | |||
3476 | Twine(G.Index)); | |||
3477 | OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n"; | |||
3478 | } | |||
3479 | } | |||
3480 | ||||
3481 | if (V.empty()) | |||
3482 | OS << "There are no section groups in this file.\n"; | |||
3483 | } | |||
3484 | ||||
3485 | template <class ELFT> | |||
3486 | void GNUELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) { | |||
3487 | OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n"; | |||
3488 | } | |||
3489 | ||||
3490 | template <class ELFT> | |||
3491 | void GNUELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R, | |||
3492 | const RelSymbol<ELFT> &RelSym) { | |||
3493 | // First two fields are bit width dependent. The rest of them are fixed width. | |||
3494 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3495 | Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; | |||
3496 | unsigned Width = ELFT::Is64Bits ? 16 : 8; | |||
3497 | ||||
3498 | Fields[0].Str = to_string(format_hex_no_prefix(R.Offset, Width)); | |||
3499 | Fields[1].Str = to_string(format_hex_no_prefix(R.Info, Width)); | |||
3500 | ||||
3501 | SmallString<32> RelocName; | |||
3502 | this->Obj.getRelocationTypeName(R.Type, RelocName); | |||
3503 | Fields[2].Str = RelocName.c_str(); | |||
3504 | ||||
3505 | if (RelSym.Sym) | |||
3506 | Fields[3].Str = | |||
3507 | to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width)); | |||
3508 | ||||
3509 | Fields[4].Str = std::string(RelSym.Name); | |||
3510 | for (const Field &F : Fields) | |||
3511 | printField(F); | |||
3512 | ||||
3513 | std::string Addend; | |||
3514 | if (Optional<int64_t> A = R.Addend) { | |||
3515 | int64_t RelAddend = *A; | |||
3516 | if (!RelSym.Name.empty()) { | |||
3517 | if (RelAddend < 0) { | |||
3518 | Addend = " - "; | |||
3519 | RelAddend = std::abs(RelAddend); | |||
3520 | } else { | |||
3521 | Addend = " + "; | |||
3522 | } | |||
3523 | } | |||
3524 | Addend += to_hexString(RelAddend, false); | |||
3525 | } | |||
3526 | OS << Addend << "\n"; | |||
3527 | } | |||
3528 | ||||
3529 | template <class ELFT> | |||
3530 | static void printRelocHeaderFields(formatted_raw_ostream &OS, unsigned SType) { | |||
3531 | bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA; | |||
3532 | bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR; | |||
3533 | if (ELFT::Is64Bits) | |||
3534 | OS << " "; | |||
3535 | else | |||
3536 | OS << " "; | |||
3537 | if (IsRelr && opts::RawRelr) | |||
3538 | OS << "Data "; | |||
3539 | else | |||
3540 | OS << "Offset"; | |||
3541 | if (ELFT::Is64Bits) | |||
3542 | OS << " Info Type" | |||
3543 | << " Symbol's Value Symbol's Name"; | |||
3544 | else | |||
3545 | OS << " Info Type Sym. Value Symbol's Name"; | |||
3546 | if (IsRela) | |||
3547 | OS << " + Addend"; | |||
3548 | OS << "\n"; | |||
3549 | } | |||
3550 | ||||
3551 | template <class ELFT> | |||
3552 | void GNUELFDumper<ELFT>::printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
3553 | const DynRegionInfo &Reg) { | |||
3554 | uint64_t Offset = Reg.Addr - this->Obj.base(); | |||
3555 | OS << "\n'" << Name.str().c_str() << "' relocation section at offset 0x" | |||
3556 | << to_hexString(Offset, false) << " contains " << Reg.Size << " bytes:\n"; | |||
3557 | printRelocHeaderFields<ELFT>(OS, Type); | |||
3558 | } | |||
3559 | ||||
3560 | template <class ELFT> | |||
3561 | static bool isRelocationSec(const typename ELFT::Shdr &Sec) { | |||
3562 | return Sec.sh_type == ELF::SHT_REL || Sec.sh_type == ELF::SHT_RELA || | |||
3563 | Sec.sh_type == ELF::SHT_RELR || Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3564 | Sec.sh_type == ELF::SHT_ANDROID_RELA || | |||
3565 | Sec.sh_type == ELF::SHT_ANDROID_RELR; | |||
3566 | } | |||
3567 | ||||
3568 | template <class ELFT> void GNUELFDumper<ELFT>::printRelocations() { | |||
3569 | auto GetEntriesNum = [&](const Elf_Shdr &Sec) -> Expected<size_t> { | |||
3570 | // Android's packed relocation section needs to be unpacked first | |||
3571 | // to get the actual number of entries. | |||
3572 | if (Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3573 | Sec.sh_type == ELF::SHT_ANDROID_RELA) { | |||
3574 | Expected<std::vector<typename ELFT::Rela>> RelasOrErr = | |||
3575 | this->Obj.android_relas(Sec); | |||
3576 | if (!RelasOrErr) | |||
3577 | return RelasOrErr.takeError(); | |||
3578 | return RelasOrErr->size(); | |||
3579 | } | |||
3580 | ||||
3581 | if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR || | |||
3582 | Sec.sh_type == ELF::SHT_ANDROID_RELR)) { | |||
3583 | Expected<Elf_Relr_Range> RelrsOrErr = this->Obj.relrs(Sec); | |||
3584 | if (!RelrsOrErr) | |||
3585 | return RelrsOrErr.takeError(); | |||
3586 | return this->Obj.decode_relrs(*RelrsOrErr).size(); | |||
3587 | } | |||
3588 | ||||
3589 | return Sec.getEntityCount(); | |||
3590 | }; | |||
3591 | ||||
3592 | bool HasRelocSections = false; | |||
3593 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
3594 | if (!isRelocationSec<ELFT>(Sec)) | |||
3595 | continue; | |||
3596 | HasRelocSections = true; | |||
3597 | ||||
3598 | std::string EntriesNum = "<?>"; | |||
3599 | if (Expected<size_t> NumOrErr = GetEntriesNum(Sec)) | |||
3600 | EntriesNum = std::to_string(*NumOrErr); | |||
3601 | else | |||
3602 | this->reportUniqueWarning("unable to get the number of relocations in " + | |||
3603 | this->describe(Sec) + ": " + | |||
3604 | toString(NumOrErr.takeError())); | |||
3605 | ||||
3606 | uintX_t Offset = Sec.sh_offset; | |||
3607 | StringRef Name = this->getPrintableSectionName(Sec); | |||
3608 | OS << "\nRelocation section '" << Name << "' at offset 0x" | |||
3609 | << to_hexString(Offset, false) << " contains " << EntriesNum | |||
3610 | << " entries:\n"; | |||
3611 | printRelocHeaderFields<ELFT>(OS, Sec.sh_type); | |||
3612 | this->printRelocationsHelper(Sec); | |||
3613 | } | |||
3614 | if (!HasRelocSections) | |||
3615 | OS << "\nThere are no relocations in this file.\n"; | |||
3616 | } | |||
3617 | ||||
3618 | // Print the offset of a particular section from anyone of the ranges: | |||
3619 | // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER]. | |||
3620 | // If 'Type' does not fall within any of those ranges, then a string is | |||
3621 | // returned as '<unknown>' followed by the type value. | |||
3622 | static std::string getSectionTypeOffsetString(unsigned Type) { | |||
3623 | if (Type >= SHT_LOOS && Type <= SHT_HIOS) | |||
3624 | return "LOOS+0x" + to_hexString(Type - SHT_LOOS); | |||
3625 | else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC) | |||
3626 | return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC); | |||
3627 | else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER) | |||
3628 | return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER); | |||
3629 | return "0x" + to_hexString(Type) + ": <unknown>"; | |||
3630 | } | |||
3631 | ||||
3632 | static std::string getSectionTypeString(unsigned Machine, unsigned Type) { | |||
3633 | StringRef Name = getELFSectionTypeName(Machine, Type); | |||
3634 | ||||
3635 | // Handle SHT_GNU_* type names. | |||
3636 | if (Name.startswith("SHT_GNU_")) { | |||
3637 | if (Name == "SHT_GNU_HASH") | |||
3638 | return "GNU_HASH"; | |||
3639 | // E.g. SHT_GNU_verneed -> VERNEED. | |||
3640 | return Name.drop_front(8).upper(); | |||
3641 | } | |||
3642 | ||||
3643 | if (Name == "SHT_SYMTAB_SHNDX") | |||
3644 | return "SYMTAB SECTION INDICES"; | |||
3645 | ||||
3646 | if (Name.startswith("SHT_")) | |||
3647 | return Name.drop_front(4).str(); | |||
3648 | return getSectionTypeOffsetString(Type); | |||
3649 | } | |||
3650 | ||||
3651 | static void printSectionDescription(formatted_raw_ostream &OS, | |||
3652 | unsigned EMachine) { | |||
3653 | OS << "Key to Flags:\n"; | |||
3654 | OS << " W (write), A (alloc), X (execute), M (merge), S (strings), I " | |||
3655 | "(info),\n"; | |||
3656 | OS << " L (link order), O (extra OS processing required), G (group), T " | |||
3657 | "(TLS),\n"; | |||
3658 | OS << " C (compressed), x (unknown), o (OS specific), E (exclude),\n"; | |||
3659 | OS << " R (retain)"; | |||
3660 | ||||
3661 | if (EMachine == EM_X86_64) | |||
3662 | OS << ", l (large)"; | |||
3663 | else if (EMachine == EM_ARM) | |||
3664 | OS << ", y (purecode)"; | |||
3665 | ||||
3666 | OS << ", p (processor specific)\n"; | |||
3667 | } | |||
3668 | ||||
3669 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionHeaders() { | |||
3670 | unsigned Bias = ELFT::Is64Bits ? 0 : 8; | |||
3671 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
3672 | OS << "There are " << to_string(Sections.size()) | |||
3673 | << " section headers, starting at offset " | |||
3674 | << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n"; | |||
3675 | OS << "Section Headers:\n"; | |||
3676 | Field Fields[11] = { | |||
3677 | {"[Nr]", 2}, {"Name", 7}, {"Type", 25}, | |||
3678 | {"Address", 41}, {"Off", 58 - Bias}, {"Size", 65 - Bias}, | |||
3679 | {"ES", 72 - Bias}, {"Flg", 75 - Bias}, {"Lk", 79 - Bias}, | |||
3680 | {"Inf", 82 - Bias}, {"Al", 86 - Bias}}; | |||
3681 | for (const Field &F : Fields) | |||
3682 | printField(F); | |||
3683 | OS << "\n"; | |||
3684 | ||||
3685 | StringRef SecStrTable; | |||
3686 | if (Expected<StringRef> SecStrTableOrErr = | |||
3687 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
3688 | SecStrTable = *SecStrTableOrErr; | |||
3689 | else | |||
3690 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
3691 | ||||
3692 | size_t SectionIndex = 0; | |||
3693 | for (const Elf_Shdr &Sec : Sections) { | |||
3694 | Fields[0].Str = to_string(SectionIndex); | |||
3695 | if (SecStrTable.empty()) | |||
3696 | Fields[1].Str = "<no-strings>"; | |||
3697 | else | |||
3698 | Fields[1].Str = std::string(unwrapOrError<StringRef>( | |||
3699 | this->FileName, this->Obj.getSectionName(Sec, SecStrTable))); | |||
3700 | Fields[2].Str = | |||
3701 | getSectionTypeString(this->Obj.getHeader().e_machine, Sec.sh_type); | |||
3702 | Fields[3].Str = | |||
3703 | to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8)); | |||
3704 | Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); | |||
3705 | Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6)); | |||
3706 | Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); | |||
3707 | Fields[7].Str = getGNUFlags(this->Obj.getHeader().e_ident[ELF::EI_OSABI], | |||
3708 | this->Obj.getHeader().e_machine, Sec.sh_flags); | |||
3709 | Fields[8].Str = to_string(Sec.sh_link); | |||
3710 | Fields[9].Str = to_string(Sec.sh_info); | |||
3711 | Fields[10].Str = to_string(Sec.sh_addralign); | |||
3712 | ||||
3713 | OS.PadToColumn(Fields[0].Column); | |||
3714 | OS << "[" << right_justify(Fields[0].Str, 2) << "]"; | |||
3715 | for (int i = 1; i < 7; i++) | |||
3716 | printField(Fields[i]); | |||
3717 | OS.PadToColumn(Fields[7].Column); | |||
3718 | OS << right_justify(Fields[7].Str, 3); | |||
3719 | OS.PadToColumn(Fields[8].Column); | |||
3720 | OS << right_justify(Fields[8].Str, 2); | |||
3721 | OS.PadToColumn(Fields[9].Column); | |||
3722 | OS << right_justify(Fields[9].Str, 3); | |||
3723 | OS.PadToColumn(Fields[10].Column); | |||
3724 | OS << right_justify(Fields[10].Str, 2); | |||
3725 | OS << "\n"; | |||
3726 | ++SectionIndex; | |||
3727 | } | |||
3728 | printSectionDescription(OS, this->Obj.getHeader().e_machine); | |||
3729 | } | |||
3730 | ||||
3731 | template <class ELFT> | |||
3732 | void GNUELFDumper<ELFT>::printSymtabMessage(const Elf_Shdr *Symtab, | |||
3733 | size_t Entries, | |||
3734 | bool NonVisibilityBitsUsed) const { | |||
3735 | StringRef Name; | |||
3736 | if (Symtab) | |||
3737 | Name = this->getPrintableSectionName(*Symtab); | |||
3738 | if (!Name.empty()) | |||
3739 | OS << "\nSymbol table '" << Name << "'"; | |||
3740 | else | |||
3741 | OS << "\nSymbol table for image"; | |||
3742 | OS << " contains " << Entries << " entries:\n"; | |||
3743 | ||||
3744 | if (ELFT::Is64Bits) | |||
3745 | OS << " Num: Value Size Type Bind Vis"; | |||
3746 | else | |||
3747 | OS << " Num: Value Size Type Bind Vis"; | |||
3748 | ||||
3749 | if (NonVisibilityBitsUsed) | |||
3750 | OS << " "; | |||
3751 | OS << " Ndx Name\n"; | |||
3752 | } | |||
3753 | ||||
3754 | template <class ELFT> | |||
3755 | std::string | |||
3756 | GNUELFDumper<ELFT>::getSymbolSectionNdx(const Elf_Sym &Symbol, | |||
3757 | unsigned SymIndex, | |||
3758 | DataRegion<Elf_Word> ShndxTable) const { | |||
3759 | unsigned SectionIndex = Symbol.st_shndx; | |||
3760 | switch (SectionIndex) { | |||
3761 | case ELF::SHN_UNDEF: | |||
3762 | return "UND"; | |||
3763 | case ELF::SHN_ABS: | |||
3764 | return "ABS"; | |||
3765 | case ELF::SHN_COMMON: | |||
3766 | return "COM"; | |||
3767 | case ELF::SHN_XINDEX: { | |||
3768 | Expected<uint32_t> IndexOrErr = | |||
3769 | object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, ShndxTable); | |||
3770 | if (!IndexOrErr) { | |||
3771 | assert(Symbol.st_shndx == SHN_XINDEX &&(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getExtendedSymbolTableIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference") ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getExtendedSymbolTableIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3773, __extension__ __PRETTY_FUNCTION__)) | |||
3772 | "getExtendedSymbolTableIndex should only fail due to an invalid "(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getExtendedSymbolTableIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference") ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getExtendedSymbolTableIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3773, __extension__ __PRETTY_FUNCTION__)) | |||
3773 | "SHT_SYMTAB_SHNDX table/reference")(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getExtendedSymbolTableIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference") ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getExtendedSymbolTableIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3773, __extension__ __PRETTY_FUNCTION__)); | |||
3774 | this->reportUniqueWarning(IndexOrErr.takeError()); | |||
3775 | return "RSV[0xffff]"; | |||
3776 | } | |||
3777 | return to_string(format_decimal(*IndexOrErr, 3)); | |||
3778 | } | |||
3779 | default: | |||
3780 | // Find if: | |||
3781 | // Processor specific | |||
3782 | if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) | |||
3783 | return std::string("PRC[0x") + | |||
3784 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3785 | // OS specific | |||
3786 | if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) | |||
3787 | return std::string("OS[0x") + | |||
3788 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3789 | // Architecture reserved: | |||
3790 | if (SectionIndex >= ELF::SHN_LORESERVE && | |||
3791 | SectionIndex <= ELF::SHN_HIRESERVE) | |||
3792 | return std::string("RSV[0x") + | |||
3793 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3794 | // A normal section with an index | |||
3795 | return to_string(format_decimal(SectionIndex, 3)); | |||
3796 | } | |||
3797 | } | |||
3798 | ||||
3799 | template <class ELFT> | |||
3800 | void GNUELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
3801 | DataRegion<Elf_Word> ShndxTable, | |||
3802 | Optional<StringRef> StrTable, | |||
3803 | bool IsDynamic, | |||
3804 | bool NonVisibilityBitsUsed) const { | |||
3805 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3806 | Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, | |||
3807 | 31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias}; | |||
3808 | Fields[0].Str = to_string(format_decimal(SymIndex, 6)) + ":"; | |||
3809 | Fields[1].Str = | |||
3810 | to_string(format_hex_no_prefix(Symbol.st_value, ELFT::Is64Bits ? 16 : 8)); | |||
3811 | Fields[2].Str = to_string(format_decimal(Symbol.st_size, 5)); | |||
3812 | ||||
3813 | unsigned char SymbolType = Symbol.getType(); | |||
3814 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
3815 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
3816 | Fields[3].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); | |||
3817 | else | |||
3818 | Fields[3].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); | |||
3819 | ||||
3820 | Fields[4].Str = | |||
3821 | enumToString(Symbol.getBinding(), makeArrayRef(ElfSymbolBindings)); | |||
3822 | Fields[5].Str = | |||
3823 | enumToString(Symbol.getVisibility(), makeArrayRef(ElfSymbolVisibilities)); | |||
3824 | ||||
3825 | if (Symbol.st_other & ~0x3) { | |||
3826 | if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) { | |||
3827 | uint8_t Other = Symbol.st_other & ~0x3; | |||
3828 | if (Other & STO_AARCH64_VARIANT_PCS) { | |||
3829 | Other &= ~STO_AARCH64_VARIANT_PCS; | |||
3830 | Fields[5].Str += " [VARIANT_PCS"; | |||
3831 | if (Other != 0) | |||
3832 | Fields[5].Str.append(" | " + to_hexString(Other, false)); | |||
3833 | Fields[5].Str.append("]"); | |||
3834 | } | |||
3835 | } else if (this->Obj.getHeader().e_machine == ELF::EM_RISCV) { | |||
3836 | uint8_t Other = Symbol.st_other & ~0x3; | |||
3837 | if (Other & STO_RISCV_VARIANT_CC) { | |||
3838 | Other &= ~STO_RISCV_VARIANT_CC; | |||
3839 | Fields[5].Str += " [VARIANT_CC"; | |||
3840 | if (Other != 0) | |||
3841 | Fields[5].Str.append(" | " + to_hexString(Other, false)); | |||
3842 | Fields[5].Str.append("]"); | |||
3843 | } | |||
3844 | } else { | |||
3845 | Fields[5].Str += | |||
3846 | " [<other: " + to_string(format_hex(Symbol.st_other, 2)) + ">]"; | |||
3847 | } | |||
3848 | } | |||
3849 | ||||
3850 | Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0; | |||
3851 | Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex, ShndxTable); | |||
3852 | ||||
3853 | Fields[7].Str = this->getFullSymbolName(Symbol, SymIndex, ShndxTable, | |||
3854 | StrTable, IsDynamic); | |||
3855 | for (const Field &Entry : Fields) | |||
3856 | printField(Entry); | |||
3857 | OS << "\n"; | |||
3858 | } | |||
3859 | ||||
3860 | template <class ELFT> | |||
3861 | void GNUELFDumper<ELFT>::printHashedSymbol(const Elf_Sym *Symbol, | |||
3862 | unsigned SymIndex, | |||
3863 | DataRegion<Elf_Word> ShndxTable, | |||
3864 | StringRef StrTable, | |||
3865 | uint32_t Bucket) { | |||
3866 | unsigned Bias = ELFT::Is64Bits
| |||
3867 | Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias, | |||
3868 | 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias}; | |||
3869 | Fields[0].Str = to_string(format_decimal(SymIndex, 5)); | |||
3870 | Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":"; | |||
3871 | ||||
3872 | Fields[2].Str = to_string( | |||
3873 | format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits
| |||
3874 | Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5)); | |||
3875 | ||||
3876 | unsigned char SymbolType = Symbol->getType(); | |||
3877 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
3878 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
3879 | Fields[4].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); | |||
3880 | else | |||
3881 | Fields[4].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); | |||
3882 | ||||
3883 | Fields[5].Str = | |||
3884 | enumToString(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); | |||
3885 | Fields[6].Str = enumToString(Symbol->getVisibility(), | |||
3886 | makeArrayRef(ElfSymbolVisibilities)); | |||
3887 | Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable); | |||
3888 | Fields[8].Str = | |||
3889 | this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true); | |||
3890 | ||||
3891 | for (const Field &Entry : Fields) | |||
3892 | printField(Entry); | |||
3893 | OS << "\n"; | |||
3894 | } | |||
3895 | ||||
3896 | template <class ELFT> | |||
3897 | void GNUELFDumper<ELFT>::printSymbols(bool PrintSymbols, | |||
3898 | bool PrintDynamicSymbols) { | |||
3899 | if (!PrintSymbols && !PrintDynamicSymbols) | |||
3900 | return; | |||
3901 | // GNU readelf prints both the .dynsym and .symtab with --symbols. | |||
3902 | this->printSymbolsHelper(true); | |||
3903 | if (PrintSymbols) | |||
3904 | this->printSymbolsHelper(false); | |||
3905 | } | |||
3906 | ||||
3907 | template <class ELFT> | |||
3908 | void GNUELFDumper<ELFT>::printHashTableSymbols(const Elf_Hash &SysVHash) { | |||
3909 | if (this->DynamicStringTable.empty()) | |||
3910 | return; | |||
3911 | ||||
3912 | if (ELFT::Is64Bits
| |||
3913 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
3914 | else | |||
3915 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
3916 | OS << "\n"; | |||
3917 | ||||
3918 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
3919 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
3920 | if (!FirstSym
| |||
3921 | this->reportUniqueWarning( | |||
3922 | Twine("unable to print symbols for the .hash table: the " | |||
3923 | "dynamic symbol table ") + | |||
3924 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
3925 | return; | |||
3926 | } | |||
3927 | ||||
3928 | DataRegion<Elf_Word> ShndxTable( | |||
3929 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
3930 | auto Buckets = SysVHash.buckets(); | |||
3931 | auto Chains = SysVHash.chains(); | |||
3932 | for (uint32_t Buc = 0; Buc < SysVHash.nbucket; Buc++) { | |||
3933 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
3934 | continue; | |||
3935 | BitVector Visited(SysVHash.nchain); | |||
3936 | for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash.nchain; Ch = Chains[Ch]) { | |||
3937 | if (Ch == ELF::STN_UNDEF) | |||
3938 | break; | |||
3939 | ||||
3940 | if (Visited[Ch]) { | |||
3941 | this->reportUniqueWarning(".hash section is invalid: bucket " + | |||
3942 | Twine(Ch) + | |||
3943 | ": a cycle was detected in the linked chain"); | |||
3944 | break; | |||
3945 | } | |||
3946 | ||||
3947 | printHashedSymbol(FirstSym + Ch, Ch, ShndxTable, this->DynamicStringTable, | |||
3948 | Buc); | |||
3949 | Visited[Ch] = true; | |||
3950 | } | |||
3951 | } | |||
3952 | } | |||
3953 | ||||
3954 | template <class ELFT> | |||
3955 | void GNUELFDumper<ELFT>::printGnuHashTableSymbols(const Elf_GnuHash &GnuHash) { | |||
3956 | if (this->DynamicStringTable.empty()) | |||
3957 | return; | |||
3958 | ||||
3959 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
3960 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
3961 | if (!FirstSym) { | |||
3962 | this->reportUniqueWarning( | |||
3963 | Twine("unable to print symbols for the .gnu.hash table: the " | |||
3964 | "dynamic symbol table ") + | |||
3965 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
3966 | return; | |||
3967 | } | |||
3968 | ||||
3969 | auto GetSymbol = [&](uint64_t SymIndex, | |||
3970 | uint64_t SymsTotal) -> const Elf_Sym * { | |||
3971 | if (SymIndex >= SymsTotal) { | |||
3972 | this->reportUniqueWarning( | |||
3973 | "unable to print hashed symbol with index " + Twine(SymIndex) + | |||
3974 | ", which is greater than or equal to the number of dynamic symbols " | |||
3975 | "(" + | |||
3976 | Twine::utohexstr(SymsTotal) + ")"); | |||
3977 | return nullptr; | |||
3978 | } | |||
3979 | return FirstSym + SymIndex; | |||
3980 | }; | |||
3981 | ||||
3982 | Expected<ArrayRef<Elf_Word>> ValuesOrErr = | |||
3983 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHash); | |||
3984 | ArrayRef<Elf_Word> Values; | |||
3985 | if (!ValuesOrErr) | |||
3986 | this->reportUniqueWarning("unable to get hash values for the SHT_GNU_HASH " | |||
3987 | "section: " + | |||
3988 | toString(ValuesOrErr.takeError())); | |||
3989 | else | |||
3990 | Values = *ValuesOrErr; | |||
3991 | ||||
3992 | DataRegion<Elf_Word> ShndxTable( | |||
3993 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
3994 | ArrayRef<Elf_Word> Buckets = GnuHash.buckets(); | |||
3995 | for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) { | |||
3996 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
3997 | continue; | |||
3998 | uint32_t Index = Buckets[Buc]; | |||
3999 | // Print whole chain. | |||
4000 | while (true) { | |||
4001 | uint32_t SymIndex = Index++; | |||
4002 | if (const Elf_Sym *Sym = GetSymbol(SymIndex, DynSyms.size())) | |||
4003 | printHashedSymbol(Sym, SymIndex, ShndxTable, this->DynamicStringTable, | |||
4004 | Buc); | |||
4005 | else | |||
4006 | break; | |||
4007 | ||||
4008 | if (SymIndex < GnuHash.symndx) { | |||
4009 | this->reportUniqueWarning( | |||
4010 | "unable to read the hash value for symbol with index " + | |||
4011 | Twine(SymIndex) + | |||
4012 | ", which is less than the index of the first hashed symbol (" + | |||
4013 | Twine(GnuHash.symndx) + ")"); | |||
4014 | break; | |||
4015 | } | |||
4016 | ||||
4017 | // Chain ends at symbol with stopper bit. | |||
4018 | if ((Values[SymIndex - GnuHash.symndx] & 1) == 1) | |||
4019 | break; | |||
4020 | } | |||
4021 | } | |||
4022 | } | |||
4023 | ||||
4024 | template <class ELFT> void GNUELFDumper<ELFT>::printHashSymbols() { | |||
4025 | if (this->HashTable) { | |||
| ||||
4026 | OS << "\n Symbol table of .hash for image:\n"; | |||
4027 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
4028 | this->reportUniqueWarning(std::move(E)); | |||
4029 | else | |||
4030 | printHashTableSymbols(*this->HashTable); | |||
4031 | } | |||
4032 | ||||
4033 | // Try printing the .gnu.hash table. | |||
4034 | if (this->GnuHashTable) { | |||
4035 | OS << "\n Symbol table of .gnu.hash for image:\n"; | |||
4036 | if (ELFT::Is64Bits) | |||
4037 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4038 | else | |||
4039 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4040 | OS << "\n"; | |||
4041 | ||||
4042 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
4043 | this->reportUniqueWarning(std::move(E)); | |||
4044 | else | |||
4045 | printGnuHashTableSymbols(*this->GnuHashTable); | |||
4046 | } | |||
4047 | } | |||
4048 | ||||
4049 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionDetails() { | |||
4050 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
4051 | OS << "There are " << to_string(Sections.size()) | |||
4052 | << " section headers, starting at offset " | |||
4053 | << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n"; | |||
4054 | ||||
4055 | OS << "Section Headers:\n"; | |||
4056 | ||||
4057 | auto PrintFields = [&](ArrayRef<Field> V) { | |||
4058 | for (const Field &F : V) | |||
4059 | printField(F); | |||
4060 | OS << "\n"; | |||
4061 | }; | |||
4062 | ||||
4063 | PrintFields({{"[Nr]", 2}, {"Name", 7}}); | |||
4064 | ||||
4065 | constexpr bool Is64 = ELFT::Is64Bits; | |||
4066 | PrintFields({{"Type", 7}, | |||
4067 | {Is64 ? "Address" : "Addr", 23}, | |||
4068 | {"Off", Is64 ? 40 : 32}, | |||
4069 | {"Size", Is64 ? 47 : 39}, | |||
4070 | {"ES", Is64 ? 54 : 46}, | |||
4071 | {"Lk", Is64 ? 59 : 51}, | |||
4072 | {"Inf", Is64 ? 62 : 54}, | |||
4073 | {"Al", Is64 ? 66 : 57}}); | |||
4074 | PrintFields({{"Flags", 7}}); | |||
4075 | ||||
4076 | StringRef SecStrTable; | |||
4077 | if (Expected<StringRef> SecStrTableOrErr = | |||
4078 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
4079 | SecStrTable = *SecStrTableOrErr; | |||
4080 | else | |||
4081 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
4082 | ||||
4083 | size_t SectionIndex = 0; | |||
4084 | const unsigned AddrSize = Is64 ? 16 : 8; | |||
4085 | for (const Elf_Shdr &S : Sections) { | |||
4086 | StringRef Name = "<?>"; | |||
4087 | if (Expected<StringRef> NameOrErr = | |||
4088 | this->Obj.getSectionName(S, SecStrTable)) | |||
4089 | Name = *NameOrErr; | |||
4090 | else | |||
4091 | this->reportUniqueWarning(NameOrErr.takeError()); | |||
4092 | ||||
4093 | OS.PadToColumn(2); | |||
4094 | OS << "[" << right_justify(to_string(SectionIndex), 2) << "]"; | |||
4095 | PrintFields({{Name, 7}}); | |||
4096 | PrintFields( | |||
4097 | {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type), 7}, | |||
4098 | {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 23}, | |||
4099 | {to_string(format_hex_no_prefix(S.sh_offset, 6)), Is64 ? 39 : 32}, | |||
4100 | {to_string(format_hex_no_prefix(S.sh_size, 6)), Is64 ? 47 : 39}, | |||
4101 | {to_string(format_hex_no_prefix(S.sh_entsize, 2)), Is64 ? 54 : 46}, | |||
4102 | {to_string(S.sh_link), Is64 ? 59 : 51}, | |||
4103 | {to_string(S.sh_info), Is64 ? 63 : 55}, | |||
4104 | {to_string(S.sh_addralign), Is64 ? 66 : 58}}); | |||
4105 | ||||
4106 | OS.PadToColumn(7); | |||
4107 | OS << "[" << to_string(format_hex_no_prefix(S.sh_flags, AddrSize)) << "]: "; | |||
4108 | ||||
4109 | DenseMap<unsigned, StringRef> FlagToName = { | |||
4110 | {SHF_WRITE, "WRITE"}, {SHF_ALLOC, "ALLOC"}, | |||
4111 | {SHF_EXECINSTR, "EXEC"}, {SHF_MERGE, "MERGE"}, | |||
4112 | {SHF_STRINGS, "STRINGS"}, {SHF_INFO_LINK, "INFO LINK"}, | |||
4113 | {SHF_LINK_ORDER, "LINK ORDER"}, {SHF_OS_NONCONFORMING, "OS NONCONF"}, | |||
4114 | {SHF_GROUP, "GROUP"}, {SHF_TLS, "TLS"}, | |||
4115 | {SHF_COMPRESSED, "COMPRESSED"}, {SHF_EXCLUDE, "EXCLUDE"}}; | |||
4116 | ||||
4117 | uint64_t Flags = S.sh_flags; | |||
4118 | uint64_t UnknownFlags = 0; | |||
4119 | ListSeparator LS; | |||
4120 | while (Flags) { | |||
4121 | // Take the least significant bit as a flag. | |||
4122 | uint64_t Flag = Flags & -Flags; | |||
4123 | Flags -= Flag; | |||
4124 | ||||
4125 | auto It = FlagToName.find(Flag); | |||
4126 | if (It != FlagToName.end()) | |||
4127 | OS << LS << It->second; | |||
4128 | else | |||
4129 | UnknownFlags |= Flag; | |||
4130 | } | |||
4131 | ||||
4132 | auto PrintUnknownFlags = [&](uint64_t Mask, StringRef Name) { | |||
4133 | uint64_t FlagsToPrint = UnknownFlags & Mask; | |||
4134 | if (!FlagsToPrint) | |||
4135 | return; | |||
4136 | ||||
4137 | OS << LS << Name << " (" | |||
4138 | << to_string(format_hex_no_prefix(FlagsToPrint, AddrSize)) << ")"; | |||
4139 | UnknownFlags &= ~Mask; | |||
4140 | }; | |||
4141 | ||||
4142 | PrintUnknownFlags(SHF_MASKOS, "OS"); | |||
4143 | PrintUnknownFlags(SHF_MASKPROC, "PROC"); | |||
4144 | PrintUnknownFlags(uint64_t(-1), "UNKNOWN"); | |||
4145 | ||||
4146 | OS << "\n"; | |||
4147 | ++SectionIndex; | |||
4148 | } | |||
4149 | } | |||
4150 | ||||
4151 | static inline std::string printPhdrFlags(unsigned Flag) { | |||
4152 | std::string Str; | |||
4153 | Str = (Flag & PF_R) ? "R" : " "; | |||
4154 | Str += (Flag & PF_W) ? "W" : " "; | |||
4155 | Str += (Flag & PF_X) ? "E" : " "; | |||
4156 | return Str; | |||
4157 | } | |||
4158 | ||||
4159 | template <class ELFT> | |||
4160 | static bool checkTLSSections(const typename ELFT::Phdr &Phdr, | |||
4161 | const typename ELFT::Shdr &Sec) { | |||
4162 | if (Sec.sh_flags & ELF::SHF_TLS) { | |||
4163 | // .tbss must only be shown in the PT_TLS segment. | |||
4164 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4165 | return Phdr.p_type == ELF::PT_TLS; | |||
4166 | ||||
4167 | // SHF_TLS sections are only shown in PT_TLS, PT_LOAD or PT_GNU_RELRO | |||
4168 | // segments. | |||
4169 | return (Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || | |||
4170 | (Phdr.p_type == ELF::PT_GNU_RELRO); | |||
4171 | } | |||
4172 | ||||
4173 | // PT_TLS must only have SHF_TLS sections. | |||
4174 | return Phdr.p_type != ELF::PT_TLS; | |||
4175 | } | |||
4176 | ||||
4177 | template <class ELFT> | |||
4178 | static bool checkOffsets(const typename ELFT::Phdr &Phdr, | |||
4179 | const typename ELFT::Shdr &Sec) { | |||
4180 | // SHT_NOBITS sections don't need to have an offset inside the segment. | |||
4181 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4182 | return true; | |||
4183 | ||||
4184 | if (Sec.sh_offset < Phdr.p_offset) | |||
4185 | return false; | |||
4186 | ||||
4187 | // Only non-empty sections can be at the end of a segment. | |||
4188 | if (Sec.sh_size == 0) | |||
4189 | return (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz); | |||
4190 | return Sec.sh_offset + Sec.sh_size <= Phdr.p_offset + Phdr.p_filesz; | |||
4191 | } | |||
4192 | ||||
4193 | // Check that an allocatable section belongs to a virtual address | |||
4194 | // space of a segment. | |||
4195 | template <class ELFT> | |||
4196 | static bool checkVMA(const typename ELFT::Phdr &Phdr, | |||
4197 | const typename ELFT::Shdr &Sec) { | |||
4198 | if (!(Sec.sh_flags & ELF::SHF_ALLOC)) | |||
4199 | return true; | |||
4200 | ||||
4201 | if (Sec.sh_addr < Phdr.p_vaddr) | |||
4202 | return false; | |||
4203 | ||||
4204 | bool IsTbss = | |||
4205 | (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); | |||
4206 | // .tbss is special, it only has memory in PT_TLS and has NOBITS properties. | |||
4207 | bool IsTbssInNonTLS = IsTbss && Phdr.p_type != ELF::PT_TLS; | |||
4208 | // Only non-empty sections can be at the end of a segment. | |||
4209 | if (Sec.sh_size == 0 || IsTbssInNonTLS) | |||
4210 | return Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4211 | return Sec.sh_addr + Sec.sh_size <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4212 | } | |||
4213 | ||||
4214 | template <class ELFT> | |||
4215 | static bool checkPTDynamic(const typename ELFT::Phdr &Phdr, | |||
4216 | const typename ELFT::Shdr &Sec) { | |||
4217 | if (Phdr.p_type != ELF::PT_DYNAMIC || Phdr.p_memsz == 0 || Sec.sh_size != 0) | |||
4218 | return true; | |||
4219 | ||||
4220 | // We get here when we have an empty section. Only non-empty sections can be | |||
4221 | // at the start or at the end of PT_DYNAMIC. | |||
4222 | // Is section within the phdr both based on offset and VMA? | |||
4223 | bool CheckOffset = (Sec.sh_type == ELF::SHT_NOBITS) || | |||
4224 | (Sec.sh_offset > Phdr.p_offset && | |||
4225 | Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz); | |||
4226 | bool CheckVA = !(Sec.sh_flags & ELF::SHF_ALLOC) || | |||
4227 | (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz); | |||
4228 | return CheckOffset && CheckVA; | |||
4229 | } | |||
4230 | ||||
4231 | template <class ELFT> | |||
4232 | void GNUELFDumper<ELFT>::printProgramHeaders( | |||
4233 | bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { | |||
4234 | if (PrintProgramHeaders) | |||
4235 | printProgramHeaders(); | |||
4236 | ||||
4237 | // Display the section mapping along with the program headers, unless | |||
4238 | // -section-mapping is explicitly set to false. | |||
4239 | if (PrintSectionMapping != cl::BOU_FALSE) | |||
4240 | printSectionMapping(); | |||
4241 | } | |||
4242 | ||||
4243 | template <class ELFT> void GNUELFDumper<ELFT>::printProgramHeaders() { | |||
4244 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
4245 | const Elf_Ehdr &Header = this->Obj.getHeader(); | |||
4246 | Field Fields[8] = {2, 17, 26, 37 + Bias, | |||
4247 | 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; | |||
4248 | OS << "\nElf file type is " | |||
4249 | << enumToString(Header.e_type, makeArrayRef(ElfObjectFileType)) << "\n" | |||
4250 | << "Entry point " << format_hex(Header.e_entry, 3) << "\n" | |||
4251 | << "There are " << Header.e_phnum << " program headers," | |||
4252 | << " starting at offset " << Header.e_phoff << "\n\n" | |||
4253 | << "Program Headers:\n"; | |||
4254 | if (ELFT::Is64Bits) | |||
4255 | OS << " Type Offset VirtAddr PhysAddr " | |||
4256 | << " FileSiz MemSiz Flg Align\n"; | |||
4257 | else | |||
4258 | OS << " Type Offset VirtAddr PhysAddr FileSiz " | |||
4259 | << "MemSiz Flg Align\n"; | |||
4260 | ||||
4261 | unsigned Width = ELFT::Is64Bits ? 18 : 10; | |||
4262 | unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; | |||
4263 | ||||
4264 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4265 | if (!PhdrsOrErr) { | |||
4266 | this->reportUniqueWarning("unable to dump program headers: " + | |||
4267 | toString(PhdrsOrErr.takeError())); | |||
4268 | return; | |||
4269 | } | |||
4270 | ||||
4271 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4272 | Fields[0].Str = getGNUPtType(Header.e_machine, Phdr.p_type); | |||
4273 | Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8)); | |||
4274 | Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width)); | |||
4275 | Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width)); | |||
4276 | Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth)); | |||
4277 | Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth)); | |||
4278 | Fields[6].Str = printPhdrFlags(Phdr.p_flags); | |||
4279 | Fields[7].Str = to_string(format_hex(Phdr.p_align, 1)); | |||
4280 | for (const Field &F : Fields) | |||
4281 | printField(F); | |||
4282 | if (Phdr.p_type == ELF::PT_INTERP) { | |||
4283 | OS << "\n"; | |||
4284 | auto ReportBadInterp = [&](const Twine &Msg) { | |||
4285 | this->reportUniqueWarning( | |||
4286 | "unable to read program interpreter name at offset 0x" + | |||
4287 | Twine::utohexstr(Phdr.p_offset) + ": " + Msg); | |||
4288 | }; | |||
4289 | ||||
4290 | if (Phdr.p_offset >= this->Obj.getBufSize()) { | |||
4291 | ReportBadInterp("it goes past the end of the file (0x" + | |||
4292 | Twine::utohexstr(this->Obj.getBufSize()) + ")"); | |||
4293 | continue; | |||
4294 | } | |||
4295 | ||||
4296 | const char *Data = | |||
4297 | reinterpret_cast<const char *>(this->Obj.base()) + Phdr.p_offset; | |||
4298 | size_t MaxSize = this->Obj.getBufSize() - Phdr.p_offset; | |||
4299 | size_t Len = strnlen(Data, MaxSize); | |||
4300 | if (Len == MaxSize) { | |||
4301 | ReportBadInterp("it is not null-terminated"); | |||
4302 | continue; | |||
4303 | } | |||
4304 | ||||
4305 | OS << " [Requesting program interpreter: "; | |||
4306 | OS << StringRef(Data, Len) << "]"; | |||
4307 | } | |||
4308 | OS << "\n"; | |||
4309 | } | |||
4310 | } | |||
4311 | ||||
4312 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionMapping() { | |||
4313 | OS << "\n Section to Segment mapping:\n Segment Sections...\n"; | |||
4314 | DenseSet<const Elf_Shdr *> BelongsToSegment; | |||
4315 | int Phnum = 0; | |||
4316 | ||||
4317 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4318 | if (!PhdrsOrErr) { | |||
4319 | this->reportUniqueWarning( | |||
4320 | "can't read program headers to build section to segment mapping: " + | |||
4321 | toString(PhdrsOrErr.takeError())); | |||
4322 | return; | |||
4323 | } | |||
4324 | ||||
4325 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4326 | std::string Sections; | |||
4327 | OS << format(" %2.2d ", Phnum++); | |||
4328 | // Check if each section is in a segment and then print mapping. | |||
4329 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4330 | if (Sec.sh_type == ELF::SHT_NULL) | |||
4331 | continue; | |||
4332 | ||||
4333 | // readelf additionally makes sure it does not print zero sized sections | |||
4334 | // at end of segments and for PT_DYNAMIC both start and end of section | |||
4335 | // .tbss must only be shown in PT_TLS section. | |||
4336 | if (checkTLSSections<ELFT>(Phdr, Sec) && checkOffsets<ELFT>(Phdr, Sec) && | |||
4337 | checkVMA<ELFT>(Phdr, Sec) && checkPTDynamic<ELFT>(Phdr, Sec)) { | |||
4338 | Sections += | |||
4339 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4340 | " "; | |||
4341 | BelongsToSegment.insert(&Sec); | |||
4342 | } | |||
4343 | } | |||
4344 | OS << Sections << "\n"; | |||
4345 | OS.flush(); | |||
4346 | } | |||
4347 | ||||
4348 | // Display sections that do not belong to a segment. | |||
4349 | std::string Sections; | |||
4350 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4351 | if (BelongsToSegment.find(&Sec) == BelongsToSegment.end()) | |||
4352 | Sections += | |||
4353 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4354 | ' '; | |||
4355 | } | |||
4356 | if (!Sections.empty()) { | |||
4357 | OS << " None " << Sections << '\n'; | |||
4358 | OS.flush(); | |||
4359 | } | |||
4360 | } | |||
4361 | ||||
4362 | namespace { | |||
4363 | ||||
4364 | template <class ELFT> | |||
4365 | RelSymbol<ELFT> getSymbolForReloc(const ELFDumper<ELFT> &Dumper, | |||
4366 | const Relocation<ELFT> &Reloc) { | |||
4367 | using Elf_Sym = typename ELFT::Sym; | |||
4368 | auto WarnAndReturn = [&](const Elf_Sym *Sym, | |||
4369 | const Twine &Reason) -> RelSymbol<ELFT> { | |||
4370 | Dumper.reportUniqueWarning( | |||
4371 | "unable to get name of the dynamic symbol with index " + | |||
4372 | Twine(Reloc.Symbol) + ": " + Reason); | |||
4373 | return {Sym, "<corrupt>"}; | |||
4374 | }; | |||
4375 | ||||
4376 | ArrayRef<Elf_Sym> Symbols = Dumper.dynamic_symbols(); | |||
4377 | const Elf_Sym *FirstSym = Symbols.begin(); | |||
4378 | if (!FirstSym) | |||
4379 | return WarnAndReturn(nullptr, "no dynamic symbol table found"); | |||
4380 | ||||
4381 | // We might have an object without a section header. In this case the size of | |||
4382 | // Symbols is zero, because there is no way to know the size of the dynamic | |||
4383 | // table. We should allow this case and not print a warning. | |||
4384 | if (!Symbols.empty() && Reloc.Symbol >= Symbols.size()) | |||
4385 | return WarnAndReturn( | |||
4386 | nullptr, | |||
4387 | "index is greater than or equal to the number of dynamic symbols (" + | |||
4388 | Twine(Symbols.size()) + ")"); | |||
4389 | ||||
4390 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
4391 | const uint64_t FileSize = Obj.getBufSize(); | |||
4392 | const uint64_t SymOffset = ((const uint8_t *)FirstSym - Obj.base()) + | |||
4393 | (uint64_t)Reloc.Symbol * sizeof(Elf_Sym); | |||
4394 | if (SymOffset + sizeof(Elf_Sym) > FileSize) | |||
4395 | return WarnAndReturn(nullptr, "symbol at 0x" + Twine::utohexstr(SymOffset) + | |||
4396 | " goes past the end of the file (0x" + | |||
4397 | Twine::utohexstr(FileSize) + ")"); | |||
4398 | ||||
4399 | const Elf_Sym *Sym = FirstSym + Reloc.Symbol; | |||
4400 | Expected<StringRef> ErrOrName = Sym->getName(Dumper.getDynamicStringTable()); | |||
4401 | if (!ErrOrName) | |||
4402 | return WarnAndReturn(Sym, toString(ErrOrName.takeError())); | |||
4403 | ||||
4404 | return {Sym == FirstSym ? nullptr : Sym, maybeDemangle(*ErrOrName)}; | |||
4405 | } | |||
4406 | } // namespace | |||
4407 | ||||
4408 | template <class ELFT> | |||
4409 | static size_t getMaxDynamicTagSize(const ELFFile<ELFT> &Obj, | |||
4410 | typename ELFT::DynRange Tags) { | |||
4411 | size_t Max = 0; | |||
4412 | for (const typename ELFT::Dyn &Dyn : Tags) | |||
4413 | Max = std::max(Max, Obj.getDynamicTagAsString(Dyn.d_tag).size()); | |||
4414 | return Max; | |||
4415 | } | |||
4416 | ||||
4417 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicTable() { | |||
4418 | Elf_Dyn_Range Table = this->dynamic_table(); | |||
4419 | if (Table.empty()) | |||
4420 | return; | |||
4421 | ||||
4422 | OS << "Dynamic section at offset " | |||
4423 | << format_hex(reinterpret_cast<const uint8_t *>(this->DynamicTable.Addr) - | |||
4424 | this->Obj.base(), | |||
4425 | 1) | |||
4426 | << " contains " << Table.size() << " entries:\n"; | |||
4427 | ||||
4428 | // The type name is surrounded with round brackets, hence add 2. | |||
4429 | size_t MaxTagSize = getMaxDynamicTagSize(this->Obj, Table) + 2; | |||
4430 | // The "Name/Value" column should be indented from the "Type" column by N | |||
4431 | // spaces, where N = MaxTagSize - length of "Type" (4) + trailing | |||
4432 | // space (1) = 3. | |||
4433 | OS << " Tag" + std::string(ELFT::Is64Bits ? 16 : 8, ' ') + "Type" | |||
4434 | << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; | |||
4435 | ||||
4436 | std::string ValueFmt = " %-" + std::to_string(MaxTagSize) + "s "; | |||
4437 | for (auto Entry : Table) { | |||
4438 | uintX_t Tag = Entry.getTag(); | |||
4439 | std::string Type = | |||
4440 | std::string("(") + this->Obj.getDynamicTagAsString(Tag) + ")"; | |||
4441 | std::string Value = this->getDynamicEntry(Tag, Entry.getVal()); | |||
4442 | OS << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10) | |||
4443 | << format(ValueFmt.c_str(), Type.c_str()) << Value << "\n"; | |||
4444 | } | |||
4445 | } | |||
4446 | ||||
4447 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicRelocations() { | |||
4448 | this->printDynamicRelocationsHelper(); | |||
4449 | } | |||
4450 | ||||
4451 | template <class ELFT> | |||
4452 | void ELFDumper<ELFT>::printDynamicReloc(const Relocation<ELFT> &R) { | |||
4453 | printRelRelaReloc(R, getSymbolForReloc(*this, R)); | |||
4454 | } | |||
4455 | ||||
4456 | template <class ELFT> | |||
4457 | void ELFDumper<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) { | |||
4458 | this->forEachRelocationDo( | |||
4459 | Sec, opts::RawRelr, | |||
4460 | [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec, | |||
4461 | const Elf_Shdr *SymTab) { printReloc(R, Ndx, Sec, SymTab); }, | |||
4462 | [&](const Elf_Relr &R) { printRelrReloc(R); }); | |||
4463 | } | |||
4464 | ||||
4465 | template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocationsHelper() { | |||
4466 | const bool IsMips64EL = this->Obj.isMips64EL(); | |||
4467 | if (this->DynRelaRegion.Size > 0) { | |||
4468 | printDynamicRelocHeader(ELF::SHT_RELA, "RELA", this->DynRelaRegion); | |||
4469 | for (const Elf_Rela &Rela : | |||
4470 | this->DynRelaRegion.template getAsArrayRef<Elf_Rela>()) | |||
4471 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4472 | } | |||
4473 | ||||
4474 | if (this->DynRelRegion.Size > 0) { | |||
4475 | printDynamicRelocHeader(ELF::SHT_REL, "REL", this->DynRelRegion); | |||
4476 | for (const Elf_Rel &Rel : | |||
4477 | this->DynRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4478 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4479 | } | |||
4480 | ||||
4481 | if (this->DynRelrRegion.Size > 0) { | |||
4482 | printDynamicRelocHeader(ELF::SHT_REL, "RELR", this->DynRelrRegion); | |||
4483 | Elf_Relr_Range Relrs = | |||
4484 | this->DynRelrRegion.template getAsArrayRef<Elf_Relr>(); | |||
4485 | for (const Elf_Rel &Rel : Obj.decode_relrs(Relrs)) | |||
4486 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4487 | } | |||
4488 | ||||
4489 | if (this->DynPLTRelRegion.Size) { | |||
4490 | if (this->DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { | |||
4491 | printDynamicRelocHeader(ELF::SHT_RELA, "PLT", this->DynPLTRelRegion); | |||
4492 | for (const Elf_Rela &Rela : | |||
4493 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rela>()) | |||
4494 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4495 | } else { | |||
4496 | printDynamicRelocHeader(ELF::SHT_REL, "PLT", this->DynPLTRelRegion); | |||
4497 | for (const Elf_Rel &Rel : | |||
4498 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4499 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4500 | } | |||
4501 | } | |||
4502 | } | |||
4503 | ||||
4504 | template <class ELFT> | |||
4505 | void GNUELFDumper<ELFT>::printGNUVersionSectionProlog( | |||
4506 | const typename ELFT::Shdr &Sec, const Twine &Label, unsigned EntriesNum) { | |||
4507 | // Don't inline the SecName, because it might report a warning to stderr and | |||
4508 | // corrupt the output. | |||
4509 | StringRef SecName = this->getPrintableSectionName(Sec); | |||
4510 | OS << Label << " section '" << SecName << "' " | |||
4511 | << "contains " << EntriesNum << " entries:\n"; | |||
4512 | ||||
4513 | StringRef LinkedSecName = "<corrupt>"; | |||
4514 | if (Expected<const typename ELFT::Shdr *> LinkedSecOrErr = | |||
4515 | this->Obj.getSection(Sec.sh_link)) | |||
4516 | LinkedSecName = this->getPrintableSectionName(**LinkedSecOrErr); | |||
4517 | else | |||
4518 | this->reportUniqueWarning("invalid section linked to " + | |||
4519 | this->describe(Sec) + ": " + | |||
4520 | toString(LinkedSecOrErr.takeError())); | |||
4521 | ||||
4522 | OS << " Addr: " << format_hex_no_prefix(Sec.sh_addr, 16) | |||
4523 | << " Offset: " << format_hex(Sec.sh_offset, 8) | |||
4524 | << " Link: " << Sec.sh_link << " (" << LinkedSecName << ")\n"; | |||
4525 | } | |||
4526 | ||||
4527 | template <class ELFT> | |||
4528 | void GNUELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) { | |||
4529 | if (!Sec) | |||
4530 | return; | |||
4531 | ||||
4532 | printGNUVersionSectionProlog(*Sec, "Version symbols", | |||
4533 | Sec->sh_size / sizeof(Elf_Versym)); | |||
4534 | Expected<ArrayRef<Elf_Versym>> VerTableOrErr = | |||
4535 | this->getVersionTable(*Sec, /*SymTab=*/nullptr, | |||
4536 | /*StrTab=*/nullptr, /*SymTabSec=*/nullptr); | |||
4537 | if (!VerTableOrErr) { | |||
4538 | this->reportUniqueWarning(VerTableOrErr.takeError()); | |||
4539 | return; | |||
4540 | } | |||
4541 | ||||
4542 | SmallVector<Optional<VersionEntry>, 0> *VersionMap = nullptr; | |||
4543 | if (Expected<SmallVector<Optional<VersionEntry>, 0> *> MapOrErr = | |||
4544 | this->getVersionMap()) | |||
4545 | VersionMap = *MapOrErr; | |||
4546 | else | |||
4547 | this->reportUniqueWarning(MapOrErr.takeError()); | |||
4548 | ||||
4549 | ArrayRef<Elf_Versym> VerTable = *VerTableOrErr; | |||
4550 | std::vector<StringRef> Versions; | |||
4551 | for (size_t I = 0, E = VerTable.size(); I < E; ++I) { | |||
4552 | unsigned Ndx = VerTable[I].vs_index; | |||
4553 | if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) { | |||
4554 | Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*"); | |||
4555 | continue; | |||
4556 | } | |||
4557 | ||||
4558 | if (!VersionMap) { | |||
4559 | Versions.emplace_back("<corrupt>"); | |||
4560 | continue; | |||
4561 | } | |||
4562 | ||||
4563 | bool IsDefault; | |||
4564 | Expected<StringRef> NameOrErr = this->Obj.getSymbolVersionByIndex( | |||
4565 | Ndx, IsDefault, *VersionMap, /*IsSymHidden=*/None); | |||
4566 | if (!NameOrErr) { | |||
4567 | this->reportUniqueWarning("unable to get a version for entry " + | |||
4568 | Twine(I) + " of " + this->describe(*Sec) + | |||
4569 | ": " + toString(NameOrErr.takeError())); | |||
4570 | Versions.emplace_back("<corrupt>"); | |||
4571 | continue; | |||
4572 | } | |||
4573 | Versions.emplace_back(*NameOrErr); | |||
4574 | } | |||
4575 | ||||
4576 | // readelf prints 4 entries per line. | |||
4577 | uint64_t Entries = VerTable.size(); | |||
4578 | for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) { | |||
4579 | OS << " " << format_hex_no_prefix(VersymRow, 3) << ":"; | |||
4580 | for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) { | |||
4581 | unsigned Ndx = VerTable[VersymRow + I].vs_index; | |||
4582 | OS << format("%4x%c", Ndx & VERSYM_VERSION, | |||
4583 | Ndx & VERSYM_HIDDEN ? 'h' : ' '); | |||
4584 | OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13); | |||
4585 | } | |||
4586 | OS << '\n'; | |||
4587 | } | |||
4588 | OS << '\n'; | |||
4589 | } | |||
4590 | ||||
4591 | static std::string versionFlagToString(unsigned Flags) { | |||
4592 | if (Flags == 0) | |||
4593 | return "none"; | |||
4594 | ||||
4595 | std::string Ret; | |||
4596 | auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) { | |||
4597 | if (!(Flags & Flag)) | |||
4598 | return; | |||
4599 | if (!Ret.empty()) | |||
4600 | Ret += " | "; | |||
4601 | Ret += Name; | |||
4602 | Flags &= ~Flag; | |||
4603 | }; | |||
4604 | ||||
4605 | AddFlag(VER_FLG_BASE, "BASE"); | |||
4606 | AddFlag(VER_FLG_WEAK, "WEAK"); | |||
4607 | AddFlag(VER_FLG_INFO, "INFO"); | |||
4608 | AddFlag(~0, "<unknown>"); | |||
4609 | return Ret; | |||
4610 | } | |||
4611 | ||||
4612 | template <class ELFT> | |||
4613 | void GNUELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) { | |||
4614 | if (!Sec) | |||
4615 | return; | |||
4616 | ||||
4617 | printGNUVersionSectionProlog(*Sec, "Version definition", Sec->sh_info); | |||
4618 | ||||
4619 | Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec); | |||
4620 | if (!V) { | |||
4621 | this->reportUniqueWarning(V.takeError()); | |||
4622 | return; | |||
4623 | } | |||
4624 | ||||
4625 | for (const VerDef &Def : *V) { | |||
4626 | OS << format(" 0x%04x: Rev: %u Flags: %s Index: %u Cnt: %u Name: %s\n", | |||
4627 | Def.Offset, Def.Version, | |||
4628 | versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt, | |||
4629 | Def.Name.data()); | |||
4630 | unsigned I = 0; | |||
4631 | for (const VerdAux &Aux : Def.AuxV) | |||
4632 | OS << format(" 0x%04x: Parent %u: %s\n", Aux.Offset, ++I, | |||
4633 | Aux.Name.data()); | |||
4634 | } | |||
4635 | ||||
4636 | OS << '\n'; | |||
4637 | } | |||
4638 | ||||
4639 | template <class ELFT> | |||
4640 | void GNUELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) { | |||
4641 | if (!Sec) | |||
4642 | return; | |||
4643 | ||||
4644 | unsigned VerneedNum = Sec->sh_info; | |||
4645 | printGNUVersionSectionProlog(*Sec, "Version needs", VerneedNum); | |||
4646 | ||||
4647 | Expected<std::vector<VerNeed>> V = | |||
4648 | this->Obj.getVersionDependencies(*Sec, this->WarningHandler); | |||
4649 | if (!V) { | |||
4650 | this->reportUniqueWarning(V.takeError()); | |||
4651 | return; | |||
4652 | } | |||
4653 | ||||
4654 | for (const VerNeed &VN : *V) { | |||
4655 | OS << format(" 0x%04x: Version: %u File: %s Cnt: %u\n", VN.Offset, | |||
4656 | VN.Version, VN.File.data(), VN.Cnt); | |||
4657 | for (const VernAux &Aux : VN.AuxV) | |||
4658 | OS << format(" 0x%04x: Name: %s Flags: %s Version: %u\n", Aux.Offset, | |||
4659 | Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(), | |||
4660 | Aux.Other); | |||
4661 | } | |||
4662 | OS << '\n'; | |||
4663 | } | |||
4664 | ||||
4665 | template <class ELFT> | |||
4666 | void GNUELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) { | |||
4667 | size_t NBucket = HashTable.nbucket; | |||
4668 | size_t NChain = HashTable.nchain; | |||
4669 | ArrayRef<Elf_Word> Buckets = HashTable.buckets(); | |||
4670 | ArrayRef<Elf_Word> Chains = HashTable.chains(); | |||
4671 | size_t TotalSyms = 0; | |||
4672 | // If hash table is correct, we have at least chains with 0 length | |||
4673 | size_t MaxChain = 1; | |||
4674 | size_t CumulativeNonZero = 0; | |||
4675 | ||||
4676 | if (NChain == 0 || NBucket == 0) | |||
4677 | return; | |||
4678 | ||||
4679 | std::vector<size_t> ChainLen(NBucket, 0); | |||
4680 | // Go over all buckets and and note chain lengths of each bucket (total | |||
4681 | // unique chain lengths). | |||
4682 | for (size_t B = 0; B < NBucket; B++) { | |||
4683 | BitVector Visited(NChain); | |||
4684 | for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) { | |||
4685 | if (C == ELF::STN_UNDEF) | |||
4686 | break; | |||
4687 | if (Visited[C]) { | |||
4688 | this->reportUniqueWarning(".hash section is invalid: bucket " + | |||
4689 | Twine(C) + | |||
4690 | ": a cycle was detected in the linked chain"); | |||
4691 | break; | |||
4692 | } | |||
4693 | Visited[C] = true; | |||
4694 | if (MaxChain <= ++ChainLen[B]) | |||
4695 | MaxChain++; | |||
4696 | } | |||
4697 | TotalSyms += ChainLen[B]; | |||
4698 | } | |||
4699 | ||||
4700 | if (!TotalSyms) | |||
4701 | return; | |||
4702 | ||||
4703 | std::vector<size_t> Count(MaxChain, 0); | |||
4704 | // Count how long is the chain for each bucket | |||
4705 | for (size_t B = 0; B < NBucket; B++) | |||
4706 | ++Count[ChainLen[B]]; | |||
4707 | // Print Number of buckets with each chain lengths and their cumulative | |||
4708 | // coverage of the symbols | |||
4709 | OS << "Histogram for bucket list length (total of " << NBucket | |||
4710 | << " buckets)\n" | |||
4711 | << " Length Number % of total Coverage\n"; | |||
4712 | for (size_t I = 0; I < MaxChain; I++) { | |||
4713 | CumulativeNonZero += Count[I] * I; | |||
4714 | OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], | |||
4715 | (Count[I] * 100.0) / NBucket, | |||
4716 | (CumulativeNonZero * 100.0) / TotalSyms); | |||
4717 | } | |||
4718 | } | |||
4719 | ||||
4720 | template <class ELFT> | |||
4721 | void GNUELFDumper<ELFT>::printGnuHashHistogram( | |||
4722 | const Elf_GnuHash &GnuHashTable) { | |||
4723 | Expected<ArrayRef<Elf_Word>> ChainsOrErr = | |||
4724 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHashTable); | |||
4725 | if (!ChainsOrErr) { | |||
4726 | this->reportUniqueWarning("unable to print the GNU hash table histogram: " + | |||
4727 | toString(ChainsOrErr.takeError())); | |||
4728 | return; | |||
4729 | } | |||
4730 | ||||
4731 | ArrayRef<Elf_Word> Chains = *ChainsOrErr; | |||
4732 | size_t Symndx = GnuHashTable.symndx; | |||
4733 | size_t TotalSyms = 0; | |||
4734 | size_t MaxChain = 1; | |||
4735 | size_t CumulativeNonZero = 0; | |||
4736 | ||||
4737 | size_t NBucket = GnuHashTable.nbuckets; | |||
4738 | if (Chains.empty() || NBucket == 0) | |||
4739 | return; | |||
4740 | ||||
4741 | ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets(); | |||
4742 | std::vector<size_t> ChainLen(NBucket, 0); | |||
4743 | for (size_t B = 0; B < NBucket; B++) { | |||
4744 | if (!Buckets[B]) | |||
4745 | continue; | |||
4746 | size_t Len = 1; | |||
4747 | for (size_t C = Buckets[B] - Symndx; | |||
4748 | C < Chains.size() && (Chains[C] & 1) == 0; C++) | |||
4749 | if (MaxChain < ++Len) | |||
4750 | MaxChain++; | |||
4751 | ChainLen[B] = Len; | |||
4752 | TotalSyms += Len; | |||
4753 | } | |||
4754 | MaxChain++; | |||
4755 | ||||
4756 | if (!TotalSyms) | |||
4757 | return; | |||
4758 | ||||
4759 | std::vector<size_t> Count(MaxChain, 0); | |||
4760 | for (size_t B = 0; B < NBucket; B++) | |||
4761 | ++Count[ChainLen[B]]; | |||
4762 | // Print Number of buckets with each chain lengths and their cumulative | |||
4763 | // coverage of the symbols | |||
4764 | OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket | |||
4765 | << " buckets)\n" | |||
4766 | << " Length Number % of total Coverage\n"; | |||
4767 | for (size_t I = 0; I < MaxChain; I++) { | |||
4768 | CumulativeNonZero += Count[I] * I; | |||
4769 | OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], | |||
4770 | (Count[I] * 100.0) / NBucket, | |||
4771 | (CumulativeNonZero * 100.0) / TotalSyms); | |||
4772 | } | |||
4773 | } | |||
4774 | ||||
4775 | // Hash histogram shows statistics of how efficient the hash was for the | |||
4776 | // dynamic symbol table. The table shows the number of hash buckets for | |||
4777 | // different lengths of chains as an absolute number and percentage of the total | |||
4778 | // buckets, and the cumulative coverage of symbols for each set of buckets. | |||
4779 | template <class ELFT> void GNUELFDumper<ELFT>::printHashHistograms() { | |||
4780 | // Print histogram for the .hash section. | |||
4781 | if (this->HashTable) { | |||
4782 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
4783 | this->reportUniqueWarning(std::move(E)); | |||
4784 | else | |||
4785 | printHashHistogram(*this->HashTable); | |||
4786 | } | |||
4787 | ||||
4788 | // Print histogram for the .gnu.hash section. | |||
4789 | if (this->GnuHashTable) { | |||
4790 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
4791 | this->reportUniqueWarning(std::move(E)); | |||
4792 | else | |||
4793 | printGnuHashHistogram(*this->GnuHashTable); | |||
4794 | } | |||
4795 | } | |||
4796 | ||||
4797 | template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() { | |||
4798 | OS << "GNUStyle::printCGProfile not implemented\n"; | |||
4799 | } | |||
4800 | ||||
4801 | template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() { | |||
4802 | OS << "GNUStyle::printBBAddrMaps not implemented\n"; | |||
4803 | } | |||
4804 | ||||
4805 | static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) { | |||
4806 | std::vector<uint64_t> Ret; | |||
4807 | const uint8_t *Cur = Data.begin(); | |||
4808 | const uint8_t *End = Data.end(); | |||
4809 | while (Cur != End) { | |||
4810 | unsigned Size; | |||
4811 | const char *Err; | |||
4812 | Ret.push_back(decodeULEB128(Cur, &Size, End, &Err)); | |||
4813 | if (Err) | |||
4814 | return createError(Err); | |||
4815 | Cur += Size; | |||
4816 | } | |||
4817 | return Ret; | |||
4818 | } | |||
4819 | ||||
4820 | template <class ELFT> | |||
4821 | static Expected<std::vector<uint64_t>> | |||
4822 | decodeAddrsigSection(const ELFFile<ELFT> &Obj, const typename ELFT::Shdr &Sec) { | |||
4823 | Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Sec); | |||
4824 | if (!ContentsOrErr) | |||
4825 | return ContentsOrErr.takeError(); | |||
4826 | ||||
4827 | if (Expected<std::vector<uint64_t>> SymsOrErr = | |||
4828 | toULEB128Array(*ContentsOrErr)) | |||
4829 | return *SymsOrErr; | |||
4830 | else | |||
4831 | return createError("unable to decode " + describe(Obj, Sec) + ": " + | |||
4832 | toString(SymsOrErr.takeError())); | |||
4833 | } | |||
4834 | ||||
4835 | template <class ELFT> void GNUELFDumper<ELFT>::printAddrsig() { | |||
4836 | if (!this->DotAddrsigSec) | |||
4837 | return; | |||
4838 | ||||
4839 | Expected<std::vector<uint64_t>> SymsOrErr = | |||
4840 | decodeAddrsigSection(this->Obj, *this->DotAddrsigSec); | |||
4841 | if (!SymsOrErr) { | |||
4842 | this->reportUniqueWarning(SymsOrErr.takeError()); | |||
4843 | return; | |||
4844 | } | |||
4845 | ||||
4846 | StringRef Name = this->getPrintableSectionName(*this->DotAddrsigSec); | |||
4847 | OS << "\nAddress-significant symbols section '" << Name << "'" | |||
4848 | << " contains " << SymsOrErr->size() << " entries:\n"; | |||
4849 | OS << " Num: Name\n"; | |||
4850 | ||||
4851 | Field Fields[2] = {0, 8}; | |||
4852 | size_t SymIndex = 0; | |||
4853 | for (uint64_t Sym : *SymsOrErr) { | |||
4854 | Fields[0].Str = to_string(format_decimal(++SymIndex, 6)) + ":"; | |||
4855 | Fields[1].Str = this->getStaticSymbolName(Sym); | |||
4856 | for (const Field &Entry : Fields) | |||
4857 | printField(Entry); | |||
4858 | OS << "\n"; | |||
4859 | } | |||
4860 | } | |||
4861 | ||||
4862 | template <typename ELFT> | |||
4863 | static std::string getGNUProperty(uint32_t Type, uint32_t DataSize, | |||
4864 | ArrayRef<uint8_t> Data) { | |||
4865 | std::string str; | |||
4866 | raw_string_ostream OS(str); | |||
4867 | uint32_t PrData; | |||
4868 | auto DumpBit = [&](uint32_t Flag, StringRef Name) { | |||
4869 | if (PrData & Flag) { | |||
4870 | PrData &= ~Flag; | |||
4871 | OS << Name; | |||
4872 | if (PrData) | |||
4873 | OS << ", "; | |||
4874 | } | |||
4875 | }; | |||
4876 | ||||
4877 | switch (Type) { | |||
4878 | default: | |||
4879 | OS << format("<application-specific type 0x%x>", Type); | |||
4880 | return OS.str(); | |||
4881 | case GNU_PROPERTY_STACK_SIZE: { | |||
4882 | OS << "stack size: "; | |||
4883 | if (DataSize == sizeof(typename ELFT::uint)) | |||
4884 | OS << formatv("{0:x}", | |||
4885 | (uint64_t)(*(const typename ELFT::Addr *)Data.data())); | |||
4886 | else | |||
4887 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4888 | return OS.str(); | |||
4889 | } | |||
4890 | case GNU_PROPERTY_NO_COPY_ON_PROTECTED: | |||
4891 | OS << "no copy on protected"; | |||
4892 | if (DataSize) | |||
4893 | OS << format(" <corrupt length: 0x%x>", DataSize); | |||
4894 | return OS.str(); | |||
4895 | case GNU_PROPERTY_AARCH64_FEATURE_1_AND: | |||
4896 | case GNU_PROPERTY_X86_FEATURE_1_AND: | |||
4897 | OS << ((Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) ? "aarch64 feature: " | |||
4898 | : "x86 feature: "); | |||
4899 | if (DataSize != 4) { | |||
4900 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4901 | return OS.str(); | |||
4902 | } | |||
4903 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
4904 | if (PrData == 0) { | |||
4905 | OS << "<None>"; | |||
4906 | return OS.str(); | |||
4907 | } | |||
4908 | if (Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) { | |||
4909 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_BTI, "BTI"); | |||
4910 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_PAC, "PAC"); | |||
4911 | } else { | |||
4912 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_IBT, "IBT"); | |||
4913 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_SHSTK, "SHSTK"); | |||
4914 | } | |||
4915 | if (PrData) | |||
4916 | OS << format("<unknown flags: 0x%x>", PrData); | |||
4917 | return OS.str(); | |||
4918 | case GNU_PROPERTY_X86_FEATURE_2_NEEDED: | |||
4919 | case GNU_PROPERTY_X86_FEATURE_2_USED: | |||
4920 | OS << "x86 feature " | |||
4921 | << (Type == GNU_PROPERTY_X86_FEATURE_2_NEEDED ? "needed: " : "used: "); | |||
4922 | if (DataSize != 4) { | |||
4923 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4924 | return OS.str(); | |||
4925 | } | |||
4926 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
4927 | if (PrData == 0) { | |||
4928 | OS << "<None>"; | |||
4929 | return OS.str(); | |||
4930 | } | |||
4931 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X86, "x86"); | |||
4932 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X87, "x87"); | |||
4933 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_MMX, "MMX"); | |||
4934 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XMM, "XMM"); | |||
4935 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_YMM, "YMM"); | |||
4936 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_ZMM, "ZMM"); | |||
4937 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_FXSR, "FXSR"); | |||
4938 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVE, "XSAVE"); | |||
4939 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT, "XSAVEOPT"); | |||
4940 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEC, "XSAVEC"); | |||
4941 | if (PrData) | |||
4942 | OS << format("<unknown flags: 0x%x>", PrData); | |||
4943 | return OS.str(); | |||
4944 | case GNU_PROPERTY_X86_ISA_1_NEEDED: | |||
4945 | case GNU_PROPERTY_X86_ISA_1_USED: | |||
4946 | OS << "x86 ISA " | |||
4947 | << (Type == GNU_PROPERTY_X86_ISA_1_NEEDED ? "needed: " : "used: "); | |||
4948 | if (DataSize != 4) { | |||
4949 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4950 | return OS.str(); | |||
4951 | } | |||
4952 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
4953 | if (PrData == 0) { | |||
4954 | OS << "<None>"; | |||
4955 | return OS.str(); | |||
4956 | } | |||
4957 | DumpBit(GNU_PROPERTY_X86_ISA_1_BASELINE, "x86-64-baseline"); | |||
4958 | DumpBit(GNU_PROPERTY_X86_ISA_1_V2, "x86-64-v2"); | |||
4959 | DumpBit(GNU_PROPERTY_X86_ISA_1_V3, "x86-64-v3"); | |||
4960 | DumpBit(GNU_PROPERTY_X86_ISA_1_V4, "x86-64-v4"); | |||
4961 | if (PrData) | |||
4962 | OS << format("<unknown flags: 0x%x>", PrData); | |||
4963 | return OS.str(); | |||
4964 | } | |||
4965 | } | |||
4966 | ||||
4967 | template <typename ELFT> | |||
4968 | static SmallVector<std::string, 4> getGNUPropertyList(ArrayRef<uint8_t> Arr) { | |||
4969 | using Elf_Word = typename ELFT::Word; | |||
4970 | ||||
4971 | SmallVector<std::string, 4> Properties; | |||
4972 | while (Arr.size() >= 8) { | |||
4973 | uint32_t Type = *reinterpret_cast<const Elf_Word *>(Arr.data()); | |||
4974 | uint32_t DataSize = *reinterpret_cast<const Elf_Word *>(Arr.data() + 4); | |||
4975 | Arr = Arr.drop_front(8); | |||
4976 | ||||
4977 | // Take padding size into account if present. | |||
4978 | uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint)); | |||
4979 | std::string str; | |||
4980 | raw_string_ostream OS(str); | |||
4981 | if (Arr.size() < PaddedSize) { | |||
4982 | OS << format("<corrupt type (0x%x) datasz: 0x%x>", Type, DataSize); | |||
4983 | Properties.push_back(OS.str()); | |||
4984 | break; | |||
4985 | } | |||
4986 | Properties.push_back( | |||
4987 | getGNUProperty<ELFT>(Type, DataSize, Arr.take_front(PaddedSize))); | |||
4988 | Arr = Arr.drop_front(PaddedSize); | |||
4989 | } | |||
4990 | ||||
4991 | if (!Arr.empty()) | |||
4992 | Properties.push_back("<corrupted GNU_PROPERTY_TYPE_0>"); | |||
4993 | ||||
4994 | return Properties; | |||
4995 | } | |||
4996 | ||||
4997 | struct GNUAbiTag { | |||
4998 | std::string OSName; | |||
4999 | std::string ABI; | |||
5000 | bool IsValid; | |||
5001 | }; | |||
5002 | ||||
5003 | template <typename ELFT> static GNUAbiTag getGNUAbiTag(ArrayRef<uint8_t> Desc) { | |||
5004 | typedef typename ELFT::Word Elf_Word; | |||
5005 | ||||
5006 | ArrayRef<Elf_Word> Words(reinterpret_cast<const Elf_Word *>(Desc.begin()), | |||
5007 | reinterpret_cast<const Elf_Word *>(Desc.end())); | |||
5008 | ||||
5009 | if (Words.size() < 4) | |||
5010 | return {"", "", /*IsValid=*/false}; | |||
5011 | ||||
5012 | static const char *OSNames[] = { | |||
5013 | "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl", | |||
5014 | }; | |||
5015 | StringRef OSName = "Unknown"; | |||
5016 | if (Words[0] < array_lengthof(OSNames)) | |||
5017 | OSName = OSNames[Words[0]]; | |||
5018 | uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3]; | |||
5019 | std::string str; | |||
5020 | raw_string_ostream ABI(str); | |||
5021 | ABI << Major << "." << Minor << "." << Patch; | |||
5022 | return {std::string(OSName), ABI.str(), /*IsValid=*/true}; | |||
5023 | } | |||
5024 | ||||
5025 | static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) { | |||
5026 | std::string str; | |||
5027 | raw_string_ostream OS(str); | |||
5028 | for (uint8_t B : Desc) | |||
5029 | OS << format_hex_no_prefix(B, 2); | |||
5030 | return OS.str(); | |||
5031 | } | |||
5032 | ||||
5033 | static StringRef getDescAsStringRef(ArrayRef<uint8_t> Desc) { | |||
5034 | return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5035 | } | |||
5036 | ||||
5037 | template <typename ELFT> | |||
5038 | static bool printGNUNote(raw_ostream &OS, uint32_t NoteType, | |||
5039 | ArrayRef<uint8_t> Desc) { | |||
5040 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5041 | switch (NoteType) { | |||
5042 | default: | |||
5043 | return false; | |||
5044 | case ELF::NT_GNU_ABI_TAG: { | |||
5045 | const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); | |||
5046 | if (!AbiTag.IsValid) | |||
5047 | OS << " <corrupt GNU_ABI_TAG>"; | |||
5048 | else | |||
5049 | OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI; | |||
5050 | break; | |||
5051 | } | |||
5052 | case ELF::NT_GNU_BUILD_ID: { | |||
5053 | OS << " Build ID: " << getGNUBuildId(Desc); | |||
5054 | break; | |||
5055 | } | |||
5056 | case ELF::NT_GNU_GOLD_VERSION: | |||
5057 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5058 | break; | |||
5059 | case ELF::NT_GNU_PROPERTY_TYPE_0: | |||
5060 | OS << " Properties:"; | |||
5061 | for (const std::string &Property : getGNUPropertyList<ELFT>(Desc)) | |||
5062 | OS << " " << Property << "\n"; | |||
5063 | break; | |||
5064 | } | |||
5065 | OS << '\n'; | |||
5066 | return true; | |||
5067 | } | |||
5068 | ||||
5069 | using AndroidNoteProperties = std::vector<std::pair<StringRef, std::string>>; | |||
5070 | static AndroidNoteProperties getAndroidNoteProperties(uint32_t NoteType, | |||
5071 | ArrayRef<uint8_t> Desc) { | |||
5072 | AndroidNoteProperties Props; | |||
5073 | switch (NoteType) { | |||
5074 | case ELF::NT_ANDROID_TYPE_MEMTAG: | |||
5075 | if (Desc.empty()) { | |||
5076 | Props.emplace_back("Invalid .note.android.memtag", ""); | |||
5077 | return Props; | |||
5078 | } | |||
5079 | ||||
5080 | switch (Desc[0] & NT_MEMTAG_LEVEL_MASK) { | |||
5081 | case NT_MEMTAG_LEVEL_NONE: | |||
5082 | Props.emplace_back("Tagging Mode", "NONE"); | |||
5083 | break; | |||
5084 | case NT_MEMTAG_LEVEL_ASYNC: | |||
5085 | Props.emplace_back("Tagging Mode", "ASYNC"); | |||
5086 | break; | |||
5087 | case NT_MEMTAG_LEVEL_SYNC: | |||
5088 | Props.emplace_back("Tagging Mode", "SYNC"); | |||
5089 | break; | |||
5090 | default: | |||
5091 | Props.emplace_back( | |||
5092 | "Tagging Mode", | |||
5093 | ("Unknown (" + Twine::utohexstr(Desc[0] & NT_MEMTAG_LEVEL_MASK) + ")") | |||
5094 | .str()); | |||
5095 | break; | |||
5096 | } | |||
5097 | Props.emplace_back("Heap", | |||
5098 | (Desc[0] & NT_MEMTAG_HEAP) ? "Enabled" : "Disabled"); | |||
5099 | Props.emplace_back("Stack", | |||
5100 | (Desc[0] & NT_MEMTAG_STACK) ? "Enabled" : "Disabled"); | |||
5101 | break; | |||
5102 | default: | |||
5103 | return Props; | |||
5104 | } | |||
5105 | return Props; | |||
5106 | } | |||
5107 | ||||
5108 | static bool printAndroidNote(raw_ostream &OS, uint32_t NoteType, | |||
5109 | ArrayRef<uint8_t> Desc) { | |||
5110 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5111 | AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc); | |||
5112 | if (Props.empty()) | |||
5113 | return false; | |||
5114 | for (const auto &KV : Props) | |||
5115 | OS << " " << KV.first << ": " << KV.second << '\n'; | |||
5116 | OS << '\n'; | |||
5117 | return true; | |||
5118 | } | |||
5119 | ||||
5120 | template <typename ELFT> | |||
5121 | static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType, | |||
5122 | ArrayRef<uint8_t> Desc) { | |||
5123 | switch (NoteType) { | |||
5124 | default: | |||
5125 | return false; | |||
5126 | case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION: | |||
5127 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5128 | break; | |||
5129 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER: | |||
5130 | OS << " Producer: " << getDescAsStringRef(Desc); | |||
5131 | break; | |||
5132 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION: | |||
5133 | OS << " Producer version: " << getDescAsStringRef(Desc); | |||
5134 | break; | |||
5135 | } | |||
5136 | OS << '\n'; | |||
5137 | return true; | |||
5138 | } | |||
5139 | ||||
5140 | const EnumEntry<unsigned> FreeBSDFeatureCtlFlags[] = { | |||
5141 | {"ASLR_DISABLE", NT_FREEBSD_FCTL_ASLR_DISABLE}, | |||
5142 | {"PROTMAX_DISABLE", NT_FREEBSD_FCTL_PROTMAX_DISABLE}, | |||
5143 | {"STKGAP_DISABLE", NT_FREEBSD_FCTL_STKGAP_DISABLE}, | |||
5144 | {"WXNEEDED", NT_FREEBSD_FCTL_WXNEEDED}, | |||
5145 | {"LA48", NT_FREEBSD_FCTL_LA48}, | |||
5146 | {"ASG_DISABLE", NT_FREEBSD_FCTL_ASG_DISABLE}, | |||
5147 | }; | |||
5148 | ||||
5149 | struct FreeBSDNote { | |||
5150 | std::string Type; | |||
5151 | std::string Value; | |||
5152 | }; | |||
5153 | ||||
5154 | template <typename ELFT> | |||
5155 | static Optional<FreeBSDNote> | |||
5156 | getFreeBSDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc, bool IsCore) { | |||
5157 | if (IsCore) | |||
5158 | return None; // No pretty-printing yet. | |||
5159 | switch (NoteType) { | |||
5160 | case ELF::NT_FREEBSD_ABI_TAG: | |||
5161 | if (Desc.size() != 4) | |||
5162 | return None; | |||
5163 | return FreeBSDNote{ | |||
5164 | "ABI tag", | |||
5165 | utostr(support::endian::read32<ELFT::TargetEndianness>(Desc.data()))}; | |||
5166 | case ELF::NT_FREEBSD_ARCH_TAG: | |||
5167 | return FreeBSDNote{"Arch tag", toStringRef(Desc).str()}; | |||
5168 | case ELF::NT_FREEBSD_FEATURE_CTL: { | |||
5169 | if (Desc.size() != 4) | |||
5170 | return None; | |||
5171 | unsigned Value = | |||
5172 | support::endian::read32<ELFT::TargetEndianness>(Desc.data()); | |||
5173 | std::string FlagsStr; | |||
5174 | raw_string_ostream OS(FlagsStr); | |||
5175 | printFlags(Value, makeArrayRef(FreeBSDFeatureCtlFlags), OS); | |||
5176 | if (OS.str().empty()) | |||
5177 | OS << "0x" << utohexstr(Value); | |||
5178 | else | |||
5179 | OS << "(0x" << utohexstr(Value) << ")"; | |||
5180 | return FreeBSDNote{"Feature flags", OS.str()}; | |||
5181 | } | |||
5182 | default: | |||
5183 | return None; | |||
5184 | } | |||
5185 | } | |||
5186 | ||||
5187 | struct AMDNote { | |||
5188 | std::string Type; | |||
5189 | std::string Value; | |||
5190 | }; | |||
5191 | ||||
5192 | template <typename ELFT> | |||
5193 | static AMDNote getAMDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5194 | switch (NoteType) { | |||
5195 | default: | |||
5196 | return {"", ""}; | |||
5197 | case ELF::NT_AMD_HSA_CODE_OBJECT_VERSION: { | |||
5198 | struct CodeObjectVersion { | |||
5199 | uint32_t MajorVersion; | |||
5200 | uint32_t MinorVersion; | |||
5201 | }; | |||
5202 | if (Desc.size() != sizeof(CodeObjectVersion)) | |||
5203 | return {"AMD HSA Code Object Version", | |||
5204 | "Invalid AMD HSA Code Object Version"}; | |||
5205 | std::string VersionString; | |||
5206 | raw_string_ostream StrOS(VersionString); | |||
5207 | auto Version = reinterpret_cast<const CodeObjectVersion *>(Desc.data()); | |||
5208 | StrOS << "[Major: " << Version->MajorVersion | |||
5209 | << ", Minor: " << Version->MinorVersion << "]"; | |||
5210 | return {"AMD HSA Code Object Version", VersionString}; | |||
5211 | } | |||
5212 | case ELF::NT_AMD_HSA_HSAIL: { | |||
5213 | struct HSAILProperties { | |||
5214 | uint32_t HSAILMajorVersion; | |||
5215 | uint32_t HSAILMinorVersion; | |||
5216 | uint8_t Profile; | |||
5217 | uint8_t MachineModel; | |||
5218 | uint8_t DefaultFloatRound; | |||
5219 | }; | |||
5220 | if (Desc.size() != sizeof(HSAILProperties)) | |||
5221 | return {"AMD HSA HSAIL Properties", "Invalid AMD HSA HSAIL Properties"}; | |||
5222 | auto Properties = reinterpret_cast<const HSAILProperties *>(Desc.data()); | |||
5223 | std::string HSAILPropetiesString; | |||
5224 | raw_string_ostream StrOS(HSAILPropetiesString); | |||
5225 | StrOS << "[HSAIL Major: " << Properties->HSAILMajorVersion | |||
5226 | << ", HSAIL Minor: " << Properties->HSAILMinorVersion | |||
5227 | << ", Profile: " << uint32_t(Properties->Profile) | |||
5228 | << ", Machine Model: " << uint32_t(Properties->MachineModel) | |||
5229 | << ", Default Float Round: " | |||
5230 | << uint32_t(Properties->DefaultFloatRound) << "]"; | |||
5231 | return {"AMD HSA HSAIL Properties", HSAILPropetiesString}; | |||
5232 | } | |||
5233 | case ELF::NT_AMD_HSA_ISA_VERSION: { | |||
5234 | struct IsaVersion { | |||
5235 | uint16_t VendorNameSize; | |||
5236 | uint16_t ArchitectureNameSize; | |||
5237 | uint32_t Major; | |||
5238 | uint32_t Minor; | |||
5239 | uint32_t Stepping; | |||
5240 | }; | |||
5241 | if (Desc.size() < sizeof(IsaVersion)) | |||
5242 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5243 | auto Isa = reinterpret_cast<const IsaVersion *>(Desc.data()); | |||
5244 | if (Desc.size() < sizeof(IsaVersion) + | |||
5245 | Isa->VendorNameSize + Isa->ArchitectureNameSize || | |||
5246 | Isa->VendorNameSize == 0 || Isa->ArchitectureNameSize == 0) | |||
5247 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5248 | std::string IsaString; | |||
5249 | raw_string_ostream StrOS(IsaString); | |||
5250 | StrOS << "[Vendor: " | |||
5251 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion), Isa->VendorNameSize - 1) | |||
5252 | << ", Architecture: " | |||
5253 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion) + Isa->VendorNameSize, | |||
5254 | Isa->ArchitectureNameSize - 1) | |||
5255 | << ", Major: " << Isa->Major << ", Minor: " << Isa->Minor | |||
5256 | << ", Stepping: " << Isa->Stepping << "]"; | |||
5257 | return {"AMD HSA ISA Version", IsaString}; | |||
5258 | } | |||
5259 | case ELF::NT_AMD_HSA_METADATA: { | |||
5260 | if (Desc.size() == 0) | |||
5261 | return {"AMD HSA Metadata", ""}; | |||
5262 | return { | |||
5263 | "AMD HSA Metadata", | |||
5264 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size() - 1)}; | |||
5265 | } | |||
5266 | case ELF::NT_AMD_HSA_ISA_NAME: { | |||
5267 | if (Desc.size() == 0) | |||
5268 | return {"AMD HSA ISA Name", ""}; | |||
5269 | return { | |||
5270 | "AMD HSA ISA Name", | |||
5271 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())}; | |||
5272 | } | |||
5273 | case ELF::NT_AMD_PAL_METADATA: { | |||
5274 | struct PALMetadata { | |||
5275 | uint32_t Key; | |||
5276 | uint32_t Value; | |||
5277 | }; | |||
5278 | if (Desc.size() % sizeof(PALMetadata) != 0) | |||
5279 | return {"AMD PAL Metadata", "Invalid AMD PAL Metadata"}; | |||
5280 | auto Isa = reinterpret_cast<const PALMetadata *>(Desc.data()); | |||
5281 | std::string MetadataString; | |||
5282 | raw_string_ostream StrOS(MetadataString); | |||
5283 | for (size_t I = 0, E = Desc.size() / sizeof(PALMetadata); I < E; ++I) { | |||
5284 | StrOS << "[" << Isa[I].Key << ": " << Isa[I].Value << "]"; | |||
5285 | } | |||
5286 | return {"AMD PAL Metadata", MetadataString}; | |||
5287 | } | |||
5288 | } | |||
5289 | } | |||
5290 | ||||
5291 | struct AMDGPUNote { | |||
5292 | std::string Type; | |||
5293 | std::string Value; | |||
5294 | }; | |||
5295 | ||||
5296 | template <typename ELFT> | |||
5297 | static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5298 | switch (NoteType) { | |||
5299 | default: | |||
5300 | return {"", ""}; | |||
5301 | case ELF::NT_AMDGPU_METADATA: { | |||
5302 | StringRef MsgPackString = | |||
5303 | StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5304 | msgpack::Document MsgPackDoc; | |||
5305 | if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false)) | |||
5306 | return {"", ""}; | |||
5307 | ||||
5308 | AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true); | |||
5309 | std::string MetadataString; | |||
5310 | if (!Verifier.verify(MsgPackDoc.getRoot())) | |||
5311 | MetadataString = "Invalid AMDGPU Metadata\n"; | |||
5312 | ||||
5313 | raw_string_ostream StrOS(MetadataString); | |||
5314 | if (MsgPackDoc.getRoot().isScalar()) { | |||
5315 | // TODO: passing a scalar root to toYAML() asserts: | |||
5316 | // (PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && | |||
5317 | // "plain scalar documents are not supported") | |||
5318 | // To avoid this crash we print the raw data instead. | |||
5319 | return {"", ""}; | |||
5320 | } | |||
5321 | MsgPackDoc.toYAML(StrOS); | |||
5322 | return {"AMDGPU Metadata", StrOS.str()}; | |||
5323 | } | |||
5324 | } | |||
5325 | } | |||
5326 | ||||
5327 | struct CoreFileMapping { | |||
5328 | uint64_t Start, End, Offset; | |||
5329 | StringRef Filename; | |||
5330 | }; | |||
5331 | ||||
5332 | struct CoreNote { | |||
5333 | uint64_t PageSize; | |||
5334 | std::vector<CoreFileMapping> Mappings; | |||
5335 | }; | |||
5336 | ||||
5337 | static Expected<CoreNote> readCoreNote(DataExtractor Desc) { | |||
5338 | // Expected format of the NT_FILE note description: | |||
5339 | // 1. # of file mappings (call it N) | |||
5340 | // 2. Page size | |||
5341 | // 3. N (start, end, offset) triples | |||
5342 | // 4. N packed filenames (null delimited) | |||
5343 | // Each field is an Elf_Addr, except for filenames which are char* strings. | |||
5344 | ||||
5345 | CoreNote Ret; | |||
5346 | const int Bytes = Desc.getAddressSize(); | |||
5347 | ||||
5348 | if (!Desc.isValidOffsetForAddress(2)) | |||
5349 | return createError("the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5350 | " is too short, expected at least 0x" + | |||
5351 | Twine::utohexstr(Bytes * 2)); | |||
5352 | if (Desc.getData().back() != 0) | |||
5353 | return createError("the note is not NUL terminated"); | |||
5354 | ||||
5355 | uint64_t DescOffset = 0; | |||
5356 | uint64_t FileCount = Desc.getAddress(&DescOffset); | |||
5357 | Ret.PageSize = Desc.getAddress(&DescOffset); | |||
5358 | ||||
5359 | if (!Desc.isValidOffsetForAddress(3 * FileCount * Bytes)) | |||
5360 | return createError("unable to read file mappings (found " + | |||
5361 | Twine(FileCount) + "): the note of size 0x" + | |||
5362 | Twine::utohexstr(Desc.size()) + " is too short"); | |||
5363 | ||||
5364 | uint64_t FilenamesOffset = 0; | |||
5365 | DataExtractor Filenames( | |||
5366 | Desc.getData().drop_front(DescOffset + 3 * FileCount * Bytes), | |||
5367 | Desc.isLittleEndian(), Desc.getAddressSize()); | |||
5368 | ||||
5369 | Ret.Mappings.resize(FileCount); | |||
5370 | size_t I = 0; | |||
5371 | for (CoreFileMapping &Mapping : Ret.Mappings) { | |||
5372 | ++I; | |||
5373 | if (!Filenames.isValidOffsetForDataOfSize(FilenamesOffset, 1)) | |||
5374 | return createError( | |||
5375 | "unable to read the file name for the mapping with index " + | |||
5376 | Twine(I) + ": the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5377 | " is truncated"); | |||
5378 | Mapping.Start = Desc.getAddress(&DescOffset); | |||
5379 | Mapping.End = Desc.getAddress(&DescOffset); | |||
5380 | Mapping.Offset = Desc.getAddress(&DescOffset); | |||
5381 | Mapping.Filename = Filenames.getCStrRef(&FilenamesOffset); | |||
5382 | } | |||
5383 | ||||
5384 | return Ret; | |||
5385 | } | |||
5386 | ||||
5387 | template <typename ELFT> | |||
5388 | static void printCoreNote(raw_ostream &OS, const CoreNote &Note) { | |||
5389 | // Length of "0x<address>" string. | |||
5390 | const int FieldWidth = ELFT::Is64Bits ? 18 : 10; | |||
5391 | ||||
5392 | OS << " Page size: " << format_decimal(Note.PageSize, 0) << '\n'; | |||
5393 | OS << " " << right_justify("Start", FieldWidth) << " " | |||
5394 | << right_justify("End", FieldWidth) << " " | |||
5395 | << right_justify("Page Offset", FieldWidth) << '\n'; | |||
5396 | for (const CoreFileMapping &Mapping : Note.Mappings) { | |||
5397 | OS << " " << format_hex(Mapping.Start, FieldWidth) << " " | |||
5398 | << format_hex(Mapping.End, FieldWidth) << " " | |||
5399 | << format_hex(Mapping.Offset, FieldWidth) << "\n " | |||
5400 | << Mapping.Filename << '\n'; | |||
5401 | } | |||
5402 | } | |||
5403 | ||||
5404 | const NoteType GenericNoteTypes[] = { | |||
5405 | {ELF::NT_VERSION, "NT_VERSION (version)"}, | |||
5406 | {ELF::NT_ARCH, "NT_ARCH (architecture)"}, | |||
5407 | {ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN, "OPEN"}, | |||
5408 | {ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC, "func"}, | |||
5409 | }; | |||
5410 | ||||
5411 | const NoteType GNUNoteTypes[] = { | |||
5412 | {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"}, | |||
5413 | {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"}, | |||
5414 | {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"}, | |||
5415 | {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"}, | |||
5416 | {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"}, | |||
5417 | }; | |||
5418 | ||||
5419 | const NoteType FreeBSDCoreNoteTypes[] = { | |||
5420 | {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"}, | |||
5421 | {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"}, | |||
5422 | {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"}, | |||
5423 | {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"}, | |||
5424 | {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"}, | |||
5425 | {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"}, | |||
5426 | {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"}, | |||
5427 | {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"}, | |||