File: | build/source/llvm/tools/llvm-readobj/ELFDumper.cpp |
Warning: | line 5948, column 9 4th function call argument is an uninitialized 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 <optional> | |||
71 | #include <string> | |||
72 | #include <system_error> | |||
73 | #include <vector> | |||
74 | ||||
75 | using namespace llvm; | |||
76 | using namespace llvm::object; | |||
77 | using namespace ELF; | |||
78 | ||||
79 | #define LLVM_READOBJ_ENUM_CASE(ns, enum)case ns::enum: return "enum"; \ | |||
80 | case ns::enum: \ | |||
81 | return #enum; | |||
82 | ||||
83 | #define ENUM_ENT(enum, altName){ "enum", altName, ELF::enum } \ | |||
84 | { #enum, altName, ELF::enum } | |||
85 | ||||
86 | #define ENUM_ENT_1(enum){ "enum", "enum", ELF::enum } \ | |||
87 | { #enum, #enum, ELF::enum } | |||
88 | ||||
89 | namespace { | |||
90 | ||||
91 | template <class ELFT> struct RelSymbol { | |||
92 | RelSymbol(const typename ELFT::Sym *S, StringRef N) | |||
93 | : Sym(S), Name(N.str()) {} | |||
94 | const typename ELFT::Sym *Sym; | |||
95 | std::string Name; | |||
96 | }; | |||
97 | ||||
98 | /// Represents a contiguous uniform range in the file. We cannot just create a | |||
99 | /// range directly because when creating one of these from the .dynamic table | |||
100 | /// the size, entity size and virtual address are different entries in arbitrary | |||
101 | /// order (DT_REL, DT_RELSZ, DT_RELENT for example). | |||
102 | struct DynRegionInfo { | |||
103 | DynRegionInfo(const Binary &Owner, const ObjDumper &D) | |||
104 | : Obj(&Owner), Dumper(&D) {} | |||
105 | DynRegionInfo(const Binary &Owner, const ObjDumper &D, const uint8_t *A, | |||
106 | uint64_t S, uint64_t ES) | |||
107 | : Addr(A), Size(S), EntSize(ES), Obj(&Owner), Dumper(&D) {} | |||
108 | ||||
109 | /// Address in current address space. | |||
110 | const uint8_t *Addr = nullptr; | |||
111 | /// Size in bytes of the region. | |||
112 | uint64_t Size = 0; | |||
113 | /// Size of each entity in the region. | |||
114 | uint64_t EntSize = 0; | |||
115 | ||||
116 | /// Owner object. Used for error reporting. | |||
117 | const Binary *Obj; | |||
118 | /// Dumper used for error reporting. | |||
119 | const ObjDumper *Dumper; | |||
120 | /// Error prefix. Used for error reporting to provide more information. | |||
121 | std::string Context; | |||
122 | /// Region size name. Used for error reporting. | |||
123 | StringRef SizePrintName = "size"; | |||
124 | /// Entry size name. Used for error reporting. If this field is empty, errors | |||
125 | /// will not mention the entry size. | |||
126 | StringRef EntSizePrintName = "entry size"; | |||
127 | ||||
128 | template <typename Type> ArrayRef<Type> getAsArrayRef() const { | |||
129 | const Type *Start = reinterpret_cast<const Type *>(Addr); | |||
130 | if (!Start) | |||
131 | return {Start, Start}; | |||
132 | ||||
133 | const uint64_t Offset = | |||
134 | Addr - (const uint8_t *)Obj->getMemoryBufferRef().getBufferStart(); | |||
135 | const uint64_t ObjSize = Obj->getMemoryBufferRef().getBufferSize(); | |||
136 | ||||
137 | if (Size > ObjSize - Offset) { | |||
138 | Dumper->reportUniqueWarning( | |||
139 | "unable to read data at 0x" + Twine::utohexstr(Offset) + | |||
140 | " of size 0x" + Twine::utohexstr(Size) + " (" + SizePrintName + | |||
141 | "): it goes past the end of the file of size 0x" + | |||
142 | Twine::utohexstr(ObjSize)); | |||
143 | return {Start, Start}; | |||
144 | } | |||
145 | ||||
146 | if (EntSize == sizeof(Type) && (Size % EntSize == 0)) | |||
147 | return {Start, Start + (Size / EntSize)}; | |||
148 | ||||
149 | std::string Msg; | |||
150 | if (!Context.empty()) | |||
151 | Msg += Context + " has "; | |||
152 | ||||
153 | Msg += ("invalid " + SizePrintName + " (0x" + Twine::utohexstr(Size) + ")") | |||
154 | .str(); | |||
155 | if (!EntSizePrintName.empty()) | |||
156 | Msg += | |||
157 | (" or " + EntSizePrintName + " (0x" + Twine::utohexstr(EntSize) + ")") | |||
158 | .str(); | |||
159 | ||||
160 | Dumper->reportUniqueWarning(Msg); | |||
161 | return {Start, Start}; | |||
162 | } | |||
163 | }; | |||
164 | ||||
165 | struct GroupMember { | |||
166 | StringRef Name; | |||
167 | uint64_t Index; | |||
168 | }; | |||
169 | ||||
170 | struct GroupSection { | |||
171 | StringRef Name; | |||
172 | std::string Signature; | |||
173 | uint64_t ShName; | |||
174 | uint64_t Index; | |||
175 | uint32_t Link; | |||
176 | uint32_t Info; | |||
177 | uint32_t Type; | |||
178 | std::vector<GroupMember> Members; | |||
179 | }; | |||
180 | ||||
181 | namespace { | |||
182 | ||||
183 | struct NoteType { | |||
184 | uint32_t ID; | |||
185 | StringRef Name; | |||
186 | }; | |||
187 | ||||
188 | } // namespace | |||
189 | ||||
190 | template <class ELFT> class Relocation { | |||
191 | public: | |||
192 | Relocation(const typename ELFT::Rel &R, bool IsMips64EL) | |||
193 | : Type(R.getType(IsMips64EL)), Symbol(R.getSymbol(IsMips64EL)), | |||
194 | Offset(R.r_offset), Info(R.r_info) {} | |||
195 | ||||
196 | Relocation(const typename ELFT::Rela &R, bool IsMips64EL) | |||
197 | : Relocation((const typename ELFT::Rel &)R, IsMips64EL) { | |||
198 | Addend = R.r_addend; | |||
199 | } | |||
200 | ||||
201 | uint32_t Type; | |||
202 | uint32_t Symbol; | |||
203 | typename ELFT::uint Offset; | |||
204 | typename ELFT::uint Info; | |||
205 | Optional<int64_t> Addend; | |||
206 | }; | |||
207 | ||||
208 | template <class ELFT> class MipsGOTParser; | |||
209 | ||||
210 | template <typename ELFT> class ELFDumper : public ObjDumper { | |||
211 | 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_Chdr = typename ELFT::Chdr; 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; | |||
212 | ||||
213 | public: | |||
214 | ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer); | |||
215 | ||||
216 | void printUnwindInfo() override; | |||
217 | void printNeededLibraries() override; | |||
218 | void printHashTable() override; | |||
219 | void printGnuHashTable() override; | |||
220 | void printLoadName() override; | |||
221 | void printVersionInfo() override; | |||
222 | void printArchSpecificInfo() override; | |||
223 | void printStackMap() const override; | |||
224 | ||||
225 | const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; }; | |||
226 | ||||
227 | std::string describe(const Elf_Shdr &Sec) const; | |||
228 | ||||
229 | unsigned getHashTableEntSize() const { | |||
230 | // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH | |||
231 | // sections. This violates the ELF specification. | |||
232 | if (Obj.getHeader().e_machine == ELF::EM_S390 || | |||
233 | Obj.getHeader().e_machine == ELF::EM_ALPHA) | |||
234 | return 8; | |||
235 | return 4; | |||
236 | } | |||
237 | ||||
238 | Elf_Dyn_Range dynamic_table() const { | |||
239 | // A valid .dynamic section contains an array of entries terminated | |||
240 | // with a DT_NULL entry. However, sometimes the section content may | |||
241 | // continue past the DT_NULL entry, so to dump the section correctly, | |||
242 | // we first find the end of the entries by iterating over them. | |||
243 | Elf_Dyn_Range Table = DynamicTable.template getAsArrayRef<Elf_Dyn>(); | |||
244 | ||||
245 | size_t Size = 0; | |||
246 | while (Size < Table.size()) | |||
247 | if (Table[Size++].getTag() == DT_NULL) | |||
248 | break; | |||
249 | ||||
250 | return Table.slice(0, Size); | |||
251 | } | |||
252 | ||||
253 | Elf_Sym_Range dynamic_symbols() const { | |||
254 | if (!DynSymRegion) | |||
255 | return Elf_Sym_Range(); | |||
256 | return DynSymRegion->template getAsArrayRef<Elf_Sym>(); | |||
257 | } | |||
258 | ||||
259 | const Elf_Shdr *findSectionByName(StringRef Name) const; | |||
260 | ||||
261 | StringRef getDynamicStringTable() const { return DynamicStringTable; } | |||
262 | ||||
263 | protected: | |||
264 | virtual void printVersionSymbolSection(const Elf_Shdr *Sec) = 0; | |||
265 | virtual void printVersionDefinitionSection(const Elf_Shdr *Sec) = 0; | |||
266 | virtual void printVersionDependencySection(const Elf_Shdr *Sec) = 0; | |||
267 | ||||
268 | void | |||
269 | printDependentLibsHelper(function_ref<void(const Elf_Shdr &)> OnSectionStart, | |||
270 | function_ref<void(StringRef, uint64_t)> OnLibEntry); | |||
271 | ||||
272 | virtual void printRelRelaReloc(const Relocation<ELFT> &R, | |||
273 | const RelSymbol<ELFT> &RelSym) = 0; | |||
274 | virtual void printRelrReloc(const Elf_Relr &R) = 0; | |||
275 | virtual void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
276 | const DynRegionInfo &Reg) {} | |||
277 | void printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
278 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab); | |||
279 | void printDynamicReloc(const Relocation<ELFT> &R); | |||
280 | void printDynamicRelocationsHelper(); | |||
281 | void printRelocationsHelper(const Elf_Shdr &Sec); | |||
282 | void forEachRelocationDo( | |||
283 | const Elf_Shdr &Sec, bool RawRelr, | |||
284 | llvm::function_ref<void(const Relocation<ELFT> &, unsigned, | |||
285 | const Elf_Shdr &, const Elf_Shdr *)> | |||
286 | RelRelaFn, | |||
287 | llvm::function_ref<void(const Elf_Relr &)> RelrFn); | |||
288 | ||||
289 | virtual void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
290 | bool NonVisibilityBitsUsed) const {}; | |||
291 | virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
292 | DataRegion<Elf_Word> ShndxTable, | |||
293 | Optional<StringRef> StrTable, bool IsDynamic, | |||
294 | bool NonVisibilityBitsUsed) const = 0; | |||
295 | ||||
296 | virtual void printMipsABIFlags() = 0; | |||
297 | virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
298 | virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
299 | ||||
300 | Expected<ArrayRef<Elf_Versym>> | |||
301 | getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
302 | StringRef *StrTab, const Elf_Shdr **SymTabSec) const; | |||
303 | StringRef getPrintableSectionName(const Elf_Shdr &Sec) const; | |||
304 | ||||
305 | std::vector<GroupSection> getGroups(); | |||
306 | ||||
307 | // Returns the function symbol index for the given address. Matches the | |||
308 | // symbol's section with FunctionSec when specified. | |||
309 | // Returns std::nullopt if no function symbol can be found for the address or | |||
310 | // in case it is not defined in the specified section. | |||
311 | SmallVector<uint32_t> | |||
312 | getSymbolIndexesForFunctionAddress(uint64_t SymValue, | |||
313 | Optional<const Elf_Shdr *> FunctionSec); | |||
314 | bool printFunctionStackSize(uint64_t SymValue, | |||
315 | Optional<const Elf_Shdr *> FunctionSec, | |||
316 | const Elf_Shdr &StackSizeSec, DataExtractor Data, | |||
317 | uint64_t *Offset); | |||
318 | void printStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec, | |||
319 | unsigned Ndx, const Elf_Shdr *SymTab, | |||
320 | const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec, | |||
321 | const RelocationResolver &Resolver, DataExtractor Data); | |||
322 | virtual void printStackSizeEntry(uint64_t Size, | |||
323 | ArrayRef<std::string> FuncNames) = 0; | |||
324 | ||||
325 | void printRelocatableStackSizes(std::function<void()> PrintHeader); | |||
326 | void printNonRelocatableStackSizes(std::function<void()> PrintHeader); | |||
327 | ||||
328 | /// Retrieves sections with corresponding relocation sections based on | |||
329 | /// IsMatch. | |||
330 | void getSectionAndRelocations( | |||
331 | std::function<bool(const Elf_Shdr &)> IsMatch, | |||
332 | llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap); | |||
333 | ||||
334 | const object::ELFObjectFile<ELFT> &ObjF; | |||
335 | const ELFFile<ELFT> &Obj; | |||
336 | StringRef FileName; | |||
337 | ||||
338 | Expected<DynRegionInfo> createDRI(uint64_t Offset, uint64_t Size, | |||
339 | uint64_t EntSize) { | |||
340 | if (Offset + Size < Offset || Offset + Size > Obj.getBufSize()) | |||
341 | return createError("offset (0x" + Twine::utohexstr(Offset) + | |||
342 | ") + size (0x" + Twine::utohexstr(Size) + | |||
343 | ") is greater than the file size (0x" + | |||
344 | Twine::utohexstr(Obj.getBufSize()) + ")"); | |||
345 | return DynRegionInfo(ObjF, *this, Obj.base() + Offset, Size, EntSize); | |||
346 | } | |||
347 | ||||
348 | void printAttributes(unsigned, std::unique_ptr<ELFAttributeParser>, | |||
349 | support::endianness); | |||
350 | void printMipsReginfo(); | |||
351 | void printMipsOptions(); | |||
352 | ||||
353 | std::pair<const Elf_Phdr *, const Elf_Shdr *> findDynamic(); | |||
354 | void loadDynamicTable(); | |||
355 | void parseDynamicTable(); | |||
356 | ||||
357 | Expected<StringRef> getSymbolVersion(const Elf_Sym &Sym, | |||
358 | bool &IsDefault) const; | |||
359 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> getVersionMap() const; | |||
360 | ||||
361 | DynRegionInfo DynRelRegion; | |||
362 | DynRegionInfo DynRelaRegion; | |||
363 | DynRegionInfo DynRelrRegion; | |||
364 | DynRegionInfo DynPLTRelRegion; | |||
365 | Optional<DynRegionInfo> DynSymRegion; | |||
366 | DynRegionInfo DynSymTabShndxRegion; | |||
367 | DynRegionInfo DynamicTable; | |||
368 | StringRef DynamicStringTable; | |||
369 | const Elf_Hash *HashTable = nullptr; | |||
370 | const Elf_GnuHash *GnuHashTable = nullptr; | |||
371 | const Elf_Shdr *DotSymtabSec = nullptr; | |||
372 | const Elf_Shdr *DotDynsymSec = nullptr; | |||
373 | const Elf_Shdr *DotAddrsigSec = nullptr; | |||
374 | DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables; | |||
375 | std::optional<uint64_t> SONameOffset; | |||
376 | std::optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap; | |||
377 | ||||
378 | const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version | |||
379 | const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r | |||
380 | const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d | |||
381 | ||||
382 | std::string getFullSymbolName(const Elf_Sym &Symbol, unsigned SymIndex, | |||
383 | DataRegion<Elf_Word> ShndxTable, | |||
384 | Optional<StringRef> StrTable, | |||
385 | bool IsDynamic) const; | |||
386 | Expected<unsigned> | |||
387 | getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
388 | DataRegion<Elf_Word> ShndxTable) const; | |||
389 | Expected<StringRef> getSymbolSectionName(const Elf_Sym &Symbol, | |||
390 | unsigned SectionIndex) const; | |||
391 | std::string getStaticSymbolName(uint32_t Index) const; | |||
392 | StringRef getDynamicString(uint64_t Value) const; | |||
393 | ||||
394 | void printSymbolsHelper(bool IsDynamic) const; | |||
395 | std::string getDynamicEntry(uint64_t Type, uint64_t Value) const; | |||
396 | ||||
397 | Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<ELFT> &R, | |||
398 | const Elf_Shdr *SymTab) const; | |||
399 | ||||
400 | ArrayRef<Elf_Word> getShndxTable(const Elf_Shdr *Symtab) const; | |||
401 | ||||
402 | private: | |||
403 | mutable SmallVector<std::optional<VersionEntry>, 0> VersionMap; | |||
404 | }; | |||
405 | ||||
406 | template <class ELFT> | |||
407 | std::string ELFDumper<ELFT>::describe(const Elf_Shdr &Sec) const { | |||
408 | return ::describe(Obj, Sec); | |||
409 | } | |||
410 | ||||
411 | namespace { | |||
412 | ||||
413 | template <class ELFT> struct SymtabLink { | |||
414 | typename ELFT::SymRange Symbols; | |||
415 | StringRef StringTable; | |||
416 | const typename ELFT::Shdr *SymTab; | |||
417 | }; | |||
418 | ||||
419 | // Returns the linked symbol table, symbols and associated string table for a | |||
420 | // given section. | |||
421 | template <class ELFT> | |||
422 | Expected<SymtabLink<ELFT>> getLinkAsSymtab(const ELFFile<ELFT> &Obj, | |||
423 | const typename ELFT::Shdr &Sec, | |||
424 | unsigned ExpectedType) { | |||
425 | Expected<const typename ELFT::Shdr *> SymtabOrErr = | |||
426 | Obj.getSection(Sec.sh_link); | |||
427 | if (!SymtabOrErr) | |||
428 | return createError("invalid section linked to " + describe(Obj, Sec) + | |||
429 | ": " + toString(SymtabOrErr.takeError())); | |||
430 | ||||
431 | if ((*SymtabOrErr)->sh_type != ExpectedType) | |||
432 | return createError( | |||
433 | "invalid section linked to " + describe(Obj, Sec) + ": expected " + | |||
434 | object::getELFSectionTypeName(Obj.getHeader().e_machine, ExpectedType) + | |||
435 | ", but got " + | |||
436 | object::getELFSectionTypeName(Obj.getHeader().e_machine, | |||
437 | (*SymtabOrErr)->sh_type)); | |||
438 | ||||
439 | Expected<StringRef> StrTabOrErr = Obj.getLinkAsStrtab(**SymtabOrErr); | |||
440 | if (!StrTabOrErr) | |||
441 | return createError( | |||
442 | "can't get a string table for the symbol table linked to " + | |||
443 | describe(Obj, Sec) + ": " + toString(StrTabOrErr.takeError())); | |||
444 | ||||
445 | Expected<typename ELFT::SymRange> SymsOrErr = Obj.symbols(*SymtabOrErr); | |||
446 | if (!SymsOrErr) | |||
447 | return createError("unable to read symbols from the " + describe(Obj, Sec) + | |||
448 | ": " + toString(SymsOrErr.takeError())); | |||
449 | ||||
450 | return SymtabLink<ELFT>{*SymsOrErr, *StrTabOrErr, *SymtabOrErr}; | |||
451 | } | |||
452 | ||||
453 | } // namespace | |||
454 | ||||
455 | template <class ELFT> | |||
456 | Expected<ArrayRef<typename ELFT::Versym>> | |||
457 | ELFDumper<ELFT>::getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
458 | StringRef *StrTab, | |||
459 | const Elf_Shdr **SymTabSec) const { | |||
460 | 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", 460, __extension__ __PRETTY_FUNCTION__)); | |||
461 | if (reinterpret_cast<uintptr_t>(Obj.base() + Sec.sh_offset) % | |||
462 | sizeof(uint16_t) != | |||
463 | 0) | |||
464 | return createError("the " + describe(Sec) + " is misaligned"); | |||
465 | ||||
466 | Expected<ArrayRef<Elf_Versym>> VersionsOrErr = | |||
467 | Obj.template getSectionContentsAsArray<Elf_Versym>(Sec); | |||
468 | if (!VersionsOrErr) | |||
469 | return createError("cannot read content of " + describe(Sec) + ": " + | |||
470 | toString(VersionsOrErr.takeError())); | |||
471 | ||||
472 | Expected<SymtabLink<ELFT>> SymTabOrErr = | |||
473 | getLinkAsSymtab(Obj, Sec, SHT_DYNSYM); | |||
474 | if (!SymTabOrErr) { | |||
475 | reportUniqueWarning(SymTabOrErr.takeError()); | |||
476 | return *VersionsOrErr; | |||
477 | } | |||
478 | ||||
479 | if (SymTabOrErr->Symbols.size() != VersionsOrErr->size()) | |||
480 | reportUniqueWarning(describe(Sec) + ": the number of entries (" + | |||
481 | Twine(VersionsOrErr->size()) + | |||
482 | ") does not match the number of symbols (" + | |||
483 | Twine(SymTabOrErr->Symbols.size()) + | |||
484 | ") in the symbol table with index " + | |||
485 | Twine(Sec.sh_link)); | |||
486 | ||||
487 | if (SymTab) { | |||
488 | *SymTab = SymTabOrErr->Symbols; | |||
489 | *StrTab = SymTabOrErr->StringTable; | |||
490 | *SymTabSec = SymTabOrErr->SymTab; | |||
491 | } | |||
492 | return *VersionsOrErr; | |||
493 | } | |||
494 | ||||
495 | template <class ELFT> | |||
496 | void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const { | |||
497 | Optional<StringRef> StrTable; | |||
498 | size_t Entries = 0; | |||
499 | Elf_Sym_Range Syms(nullptr, nullptr); | |||
500 | const Elf_Shdr *SymtabSec = IsDynamic ? DotDynsymSec : DotSymtabSec; | |||
501 | ||||
502 | if (IsDynamic) { | |||
503 | StrTable = DynamicStringTable; | |||
504 | Syms = dynamic_symbols(); | |||
505 | Entries = Syms.size(); | |||
506 | } else if (DotSymtabSec) { | |||
507 | if (Expected<StringRef> StrTableOrErr = | |||
508 | Obj.getStringTableForSymtab(*DotSymtabSec)) | |||
509 | StrTable = *StrTableOrErr; | |||
510 | else | |||
511 | reportUniqueWarning( | |||
512 | "unable to get the string table for the SHT_SYMTAB section: " + | |||
513 | toString(StrTableOrErr.takeError())); | |||
514 | ||||
515 | if (Expected<Elf_Sym_Range> SymsOrErr = Obj.symbols(DotSymtabSec)) | |||
516 | Syms = *SymsOrErr; | |||
517 | else | |||
518 | reportUniqueWarning( | |||
519 | "unable to read symbols from the SHT_SYMTAB section: " + | |||
520 | toString(SymsOrErr.takeError())); | |||
521 | Entries = DotSymtabSec->getEntityCount(); | |||
522 | } | |||
523 | if (Syms.empty()) | |||
524 | return; | |||
525 | ||||
526 | // The st_other field has 2 logical parts. The first two bits hold the symbol | |||
527 | // visibility (STV_*) and the remainder hold other platform-specific values. | |||
528 | bool NonVisibilityBitsUsed = | |||
529 | llvm::any_of(Syms, [](const Elf_Sym &S) { return S.st_other & ~0x3; }); | |||
530 | ||||
531 | DataRegion<Elf_Word> ShndxTable = | |||
532 | IsDynamic ? DataRegion<Elf_Word>( | |||
533 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, | |||
534 | this->getElfObject().getELFFile().end()) | |||
535 | : DataRegion<Elf_Word>(this->getShndxTable(SymtabSec)); | |||
536 | ||||
537 | printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed); | |||
538 | for (const Elf_Sym &Sym : Syms) | |||
539 | printSymbol(Sym, &Sym - Syms.begin(), ShndxTable, StrTable, IsDynamic, | |||
540 | NonVisibilityBitsUsed); | |||
541 | } | |||
542 | ||||
543 | template <typename ELFT> class GNUELFDumper : public ELFDumper<ELFT> { | |||
544 | formatted_raw_ostream &OS; | |||
545 | ||||
546 | public: | |||
547 | 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_Chdr = typename ELFT::Chdr; 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; | |||
548 | ||||
549 | GNUELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
550 | : ELFDumper<ELFT>(ObjF, Writer), | |||
551 | OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())) { | |||
552 | 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", 552, __extension__ __PRETTY_FUNCTION__)); | |||
553 | } | |||
554 | ||||
555 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
556 | ArrayRef<std::string> InputFilenames, | |||
557 | const Archive *A) override; | |||
558 | void printFileHeaders() override; | |||
559 | void printGroupSections() override; | |||
560 | void printRelocations() override; | |||
561 | void printSectionHeaders() override; | |||
562 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
563 | void printHashSymbols() override; | |||
564 | void printSectionDetails() override; | |||
565 | void printDependentLibs() override; | |||
566 | void printDynamicTable() override; | |||
567 | void printDynamicRelocations() override; | |||
568 | void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
569 | bool NonVisibilityBitsUsed) const override; | |||
570 | void printProgramHeaders(bool PrintProgramHeaders, | |||
571 | cl::boolOrDefault PrintSectionMapping) override; | |||
572 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
573 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
574 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
575 | void printHashHistograms() override; | |||
576 | void printCGProfile() override; | |||
577 | void printBBAddrMaps() override; | |||
578 | void printAddrsig() override; | |||
579 | void printNotes() override; | |||
580 | void printELFLinkerOptions() override; | |||
581 | void printStackSizes() override; | |||
582 | ||||
583 | private: | |||
584 | void printHashHistogram(const Elf_Hash &HashTable); | |||
585 | void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable); | |||
586 | void printHashTableSymbols(const Elf_Hash &HashTable); | |||
587 | void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable); | |||
588 | ||||
589 | struct Field { | |||
590 | std::string Str; | |||
591 | unsigned Column; | |||
592 | ||||
593 | Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {} | |||
594 | Field(unsigned Col) : Column(Col) {} | |||
595 | }; | |||
596 | ||||
597 | template <typename T, typename TEnum> | |||
598 | std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues, | |||
599 | TEnum EnumMask1 = {}, TEnum EnumMask2 = {}, | |||
600 | TEnum EnumMask3 = {}) const { | |||
601 | std::string Str; | |||
602 | for (const EnumEntry<TEnum> &Flag : EnumValues) { | |||
603 | if (Flag.Value == 0) | |||
604 | continue; | |||
605 | ||||
606 | TEnum EnumMask{}; | |||
607 | if (Flag.Value & EnumMask1) | |||
608 | EnumMask = EnumMask1; | |||
609 | else if (Flag.Value & EnumMask2) | |||
610 | EnumMask = EnumMask2; | |||
611 | else if (Flag.Value & EnumMask3) | |||
612 | EnumMask = EnumMask3; | |||
613 | bool IsEnum = (Flag.Value & EnumMask) != 0; | |||
614 | if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || | |||
615 | (IsEnum && (Value & EnumMask) == Flag.Value)) { | |||
616 | if (!Str.empty()) | |||
617 | Str += ", "; | |||
618 | Str += Flag.AltName; | |||
619 | } | |||
620 | } | |||
621 | return Str; | |||
622 | } | |||
623 | ||||
624 | formatted_raw_ostream &printField(struct Field F) const { | |||
625 | if (F.Column != 0) | |||
626 | OS.PadToColumn(F.Column); | |||
627 | OS << F.Str; | |||
628 | OS.flush(); | |||
629 | return OS; | |||
630 | } | |||
631 | void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex, | |||
632 | DataRegion<Elf_Word> ShndxTable, StringRef StrTable, | |||
633 | uint32_t Bucket); | |||
634 | void printRelrReloc(const Elf_Relr &R) override; | |||
635 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
636 | const RelSymbol<ELFT> &RelSym) override; | |||
637 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
638 | DataRegion<Elf_Word> ShndxTable, | |||
639 | Optional<StringRef> StrTable, bool IsDynamic, | |||
640 | bool NonVisibilityBitsUsed) const override; | |||
641 | void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
642 | const DynRegionInfo &Reg) override; | |||
643 | ||||
644 | std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex, | |||
645 | DataRegion<Elf_Word> ShndxTable) const; | |||
646 | void printProgramHeaders() override; | |||
647 | void printSectionMapping() override; | |||
648 | void printGNUVersionSectionProlog(const typename ELFT::Shdr &Sec, | |||
649 | const Twine &Label, unsigned EntriesNum); | |||
650 | ||||
651 | void printStackSizeEntry(uint64_t Size, | |||
652 | ArrayRef<std::string> FuncNames) override; | |||
653 | ||||
654 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
655 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
656 | void printMipsABIFlags() override; | |||
657 | }; | |||
658 | ||||
659 | template <typename ELFT> class LLVMELFDumper : public ELFDumper<ELFT> { | |||
660 | public: | |||
661 | 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_Chdr = typename ELFT::Chdr; 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; | |||
662 | ||||
663 | LLVMELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
664 | : ELFDumper<ELFT>(ObjF, Writer), W(Writer) {} | |||
665 | ||||
666 | void printFileHeaders() override; | |||
667 | void printGroupSections() override; | |||
668 | void printRelocations() override; | |||
669 | void printSectionHeaders() override; | |||
670 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
671 | void printDependentLibs() override; | |||
672 | void printDynamicTable() override; | |||
673 | void printDynamicRelocations() override; | |||
674 | void printProgramHeaders(bool PrintProgramHeaders, | |||
675 | cl::boolOrDefault PrintSectionMapping) override; | |||
676 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
677 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
678 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
679 | void printHashHistograms() override; | |||
680 | void printCGProfile() override; | |||
681 | void printBBAddrMaps() override; | |||
682 | void printAddrsig() override; | |||
683 | void printNotes() override; | |||
684 | void printELFLinkerOptions() override; | |||
685 | void printStackSizes() override; | |||
686 | ||||
687 | private: | |||
688 | void printRelrReloc(const Elf_Relr &R) override; | |||
689 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
690 | const RelSymbol<ELFT> &RelSym) override; | |||
691 | ||||
692 | void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex, | |||
693 | DataRegion<Elf_Word> ShndxTable) const; | |||
694 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
695 | DataRegion<Elf_Word> ShndxTable, | |||
696 | Optional<StringRef> StrTable, bool IsDynamic, | |||
697 | bool /*NonVisibilityBitsUsed*/) const override; | |||
698 | void printProgramHeaders() override; | |||
699 | void printSectionMapping() override {} | |||
700 | void printStackSizeEntry(uint64_t Size, | |||
701 | ArrayRef<std::string> FuncNames) override; | |||
702 | ||||
703 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
704 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
705 | void printMipsABIFlags() override; | |||
706 | ||||
707 | protected: | |||
708 | ScopedPrinter &W; | |||
709 | }; | |||
710 | ||||
711 | // JSONELFDumper shares most of the same implementation as LLVMELFDumper except | |||
712 | // it uses a JSONScopedPrinter. | |||
713 | template <typename ELFT> class JSONELFDumper : public LLVMELFDumper<ELFT> { | |||
714 | public: | |||
715 | 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_Chdr = typename ELFT::Chdr; 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; | |||
716 | ||||
717 | JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
718 | : LLVMELFDumper<ELFT>(ObjF, Writer) {} | |||
719 | ||||
720 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
721 | ArrayRef<std::string> InputFilenames, | |||
722 | const Archive *A) override; | |||
723 | ||||
724 | private: | |||
725 | std::unique_ptr<DictScope> FileScope; | |||
726 | }; | |||
727 | ||||
728 | } // end anonymous namespace | |||
729 | ||||
730 | namespace llvm { | |||
731 | ||||
732 | template <class ELFT> | |||
733 | static std::unique_ptr<ObjDumper> | |||
734 | createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) { | |||
735 | if (opts::Output == opts::GNU) | |||
736 | return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer); | |||
737 | else if (opts::Output == opts::JSON) | |||
738 | return std::make_unique<JSONELFDumper<ELFT>>(Obj, Writer); | |||
739 | return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer); | |||
740 | } | |||
741 | ||||
742 | std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj, | |||
743 | ScopedPrinter &Writer) { | |||
744 | // Little-endian 32-bit | |||
745 | if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj)) | |||
746 | return createELFDumper(*ELFObj, Writer); | |||
747 | ||||
748 | // Big-endian 32-bit | |||
749 | if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj)) | |||
750 | return createELFDumper(*ELFObj, Writer); | |||
751 | ||||
752 | // Little-endian 64-bit | |||
753 | if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj)) | |||
754 | return createELFDumper(*ELFObj, Writer); | |||
755 | ||||
756 | // Big-endian 64-bit | |||
757 | return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer); | |||
758 | } | |||
759 | ||||
760 | } // end namespace llvm | |||
761 | ||||
762 | template <class ELFT> | |||
763 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> | |||
764 | ELFDumper<ELFT>::getVersionMap() const { | |||
765 | // If the VersionMap has already been loaded or if there is no dynamic symtab | |||
766 | // or version table, there is nothing to do. | |||
767 | if (!VersionMap.empty() || !DynSymRegion || !SymbolVersionSection) | |||
768 | return &VersionMap; | |||
769 | ||||
770 | Expected<SmallVector<std::optional<VersionEntry>, 0>> MapOrErr = | |||
771 | Obj.loadVersionMap(SymbolVersionNeedSection, SymbolVersionDefSection); | |||
772 | if (MapOrErr) | |||
773 | VersionMap = *MapOrErr; | |||
774 | else | |||
775 | return MapOrErr.takeError(); | |||
776 | ||||
777 | return &VersionMap; | |||
778 | } | |||
779 | ||||
780 | template <typename ELFT> | |||
781 | Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym &Sym, | |||
782 | bool &IsDefault) const { | |||
783 | // This is a dynamic symbol. Look in the GNU symbol version table. | |||
784 | if (!SymbolVersionSection) { | |||
785 | // No version table. | |||
786 | IsDefault = false; | |||
787 | return ""; | |||
788 | } | |||
789 | ||||
790 | 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", 790, __extension__ __PRETTY_FUNCTION__)); | |||
791 | // Determine the position in the symbol table of this entry. | |||
792 | size_t EntryIndex = (reinterpret_cast<uintptr_t>(&Sym) - | |||
793 | reinterpret_cast<uintptr_t>(DynSymRegion->Addr)) / | |||
794 | sizeof(Elf_Sym); | |||
795 | ||||
796 | // Get the corresponding version index entry. | |||
797 | Expected<const Elf_Versym *> EntryOrErr = | |||
798 | Obj.template getEntry<Elf_Versym>(*SymbolVersionSection, EntryIndex); | |||
799 | if (!EntryOrErr) | |||
800 | return EntryOrErr.takeError(); | |||
801 | ||||
802 | unsigned Version = (*EntryOrErr)->vs_index; | |||
803 | if (Version == VER_NDX_LOCAL || Version == VER_NDX_GLOBAL) { | |||
804 | IsDefault = false; | |||
805 | return ""; | |||
806 | } | |||
807 | ||||
808 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> MapOrErr = | |||
809 | getVersionMap(); | |||
810 | if (!MapOrErr) | |||
811 | return MapOrErr.takeError(); | |||
812 | ||||
813 | return Obj.getSymbolVersionByIndex(Version, IsDefault, **MapOrErr, | |||
814 | Sym.st_shndx == ELF::SHN_UNDEF); | |||
815 | } | |||
816 | ||||
817 | template <typename ELFT> | |||
818 | Expected<RelSymbol<ELFT>> | |||
819 | ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R, | |||
820 | const Elf_Shdr *SymTab) const { | |||
821 | if (R.Symbol == 0) | |||
822 | return RelSymbol<ELFT>(nullptr, ""); | |||
823 | ||||
824 | Expected<const Elf_Sym *> SymOrErr = | |||
825 | Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol); | |||
826 | if (!SymOrErr) | |||
827 | return createError("unable to read an entry with index " + Twine(R.Symbol) + | |||
828 | " from " + describe(*SymTab) + ": " + | |||
829 | toString(SymOrErr.takeError())); | |||
830 | const Elf_Sym *Sym = *SymOrErr; | |||
831 | if (!Sym) | |||
832 | return RelSymbol<ELFT>(nullptr, ""); | |||
833 | ||||
834 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*SymTab); | |||
835 | if (!StrTableOrErr) | |||
836 | return StrTableOrErr.takeError(); | |||
837 | ||||
838 | const Elf_Sym *FirstSym = | |||
839 | cantFail(Obj.template getEntry<Elf_Sym>(*SymTab, 0)); | |||
840 | std::string SymbolName = | |||
841 | getFullSymbolName(*Sym, Sym - FirstSym, getShndxTable(SymTab), | |||
842 | *StrTableOrErr, SymTab->sh_type == SHT_DYNSYM); | |||
843 | return RelSymbol<ELFT>(Sym, SymbolName); | |||
844 | } | |||
845 | ||||
846 | template <typename ELFT> | |||
847 | ArrayRef<typename ELFT::Word> | |||
848 | ELFDumper<ELFT>::getShndxTable(const Elf_Shdr *Symtab) const { | |||
849 | if (Symtab) { | |||
850 | auto It = ShndxTables.find(Symtab); | |||
851 | if (It != ShndxTables.end()) | |||
852 | return It->second; | |||
853 | } | |||
854 | return {}; | |||
855 | } | |||
856 | ||||
857 | static std::string maybeDemangle(StringRef Name) { | |||
858 | return opts::Demangle ? demangle(std::string(Name)) : Name.str(); | |||
859 | } | |||
860 | ||||
861 | template <typename ELFT> | |||
862 | std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const { | |||
863 | auto Warn = [&](Error E) -> std::string { | |||
864 | reportUniqueWarning("unable to read the name of symbol with index " + | |||
865 | Twine(Index) + ": " + toString(std::move(E))); | |||
866 | return "<?>"; | |||
867 | }; | |||
868 | ||||
869 | Expected<const typename ELFT::Sym *> SymOrErr = | |||
870 | Obj.getSymbol(DotSymtabSec, Index); | |||
871 | if (!SymOrErr) | |||
872 | return Warn(SymOrErr.takeError()); | |||
873 | ||||
874 | Expected<StringRef> StrTabOrErr = Obj.getStringTableForSymtab(*DotSymtabSec); | |||
875 | if (!StrTabOrErr) | |||
876 | return Warn(StrTabOrErr.takeError()); | |||
877 | ||||
878 | Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr); | |||
879 | if (!NameOrErr) | |||
880 | return Warn(NameOrErr.takeError()); | |||
881 | return maybeDemangle(*NameOrErr); | |||
882 | } | |||
883 | ||||
884 | template <typename ELFT> | |||
885 | std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym &Symbol, | |||
886 | unsigned SymIndex, | |||
887 | DataRegion<Elf_Word> ShndxTable, | |||
888 | Optional<StringRef> StrTable, | |||
889 | bool IsDynamic) const { | |||
890 | if (!StrTable) | |||
891 | return "<?>"; | |||
892 | ||||
893 | std::string SymbolName; | |||
894 | if (Expected<StringRef> NameOrErr = Symbol.getName(*StrTable)) { | |||
895 | SymbolName = maybeDemangle(*NameOrErr); | |||
896 | } else { | |||
897 | reportUniqueWarning(NameOrErr.takeError()); | |||
898 | return "<?>"; | |||
899 | } | |||
900 | ||||
901 | if (SymbolName.empty() && Symbol.getType() == ELF::STT_SECTION) { | |||
902 | Expected<unsigned> SectionIndex = | |||
903 | getSymbolSectionIndex(Symbol, SymIndex, ShndxTable); | |||
904 | if (!SectionIndex) { | |||
905 | reportUniqueWarning(SectionIndex.takeError()); | |||
906 | return "<?>"; | |||
907 | } | |||
908 | Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex); | |||
909 | if (!NameOrErr) { | |||
910 | reportUniqueWarning(NameOrErr.takeError()); | |||
911 | return ("<section " + Twine(*SectionIndex) + ">").str(); | |||
912 | } | |||
913 | return std::string(*NameOrErr); | |||
914 | } | |||
915 | ||||
916 | if (!IsDynamic) | |||
917 | return SymbolName; | |||
918 | ||||
919 | bool IsDefault; | |||
920 | Expected<StringRef> VersionOrErr = getSymbolVersion(Symbol, IsDefault); | |||
921 | if (!VersionOrErr) { | |||
922 | reportUniqueWarning(VersionOrErr.takeError()); | |||
923 | return SymbolName + "@<corrupt>"; | |||
924 | } | |||
925 | ||||
926 | if (!VersionOrErr->empty()) { | |||
927 | SymbolName += (IsDefault ? "@@" : "@"); | |||
928 | SymbolName += *VersionOrErr; | |||
929 | } | |||
930 | return SymbolName; | |||
931 | } | |||
932 | ||||
933 | template <typename ELFT> | |||
934 | Expected<unsigned> | |||
935 | ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
936 | DataRegion<Elf_Word> ShndxTable) const { | |||
937 | unsigned Ndx = Symbol.st_shndx; | |||
938 | if (Ndx == SHN_XINDEX) | |||
939 | return object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, | |||
940 | ShndxTable); | |||
941 | if (Ndx != SHN_UNDEF && Ndx < SHN_LORESERVE) | |||
942 | return Ndx; | |||
943 | ||||
944 | auto CreateErr = [&](const Twine &Name, | |||
945 | std::optional<unsigned> Offset = std::nullopt) { | |||
946 | std::string Desc; | |||
947 | if (Offset) | |||
948 | Desc = (Name + "+0x" + Twine::utohexstr(*Offset)).str(); | |||
949 | else | |||
950 | Desc = Name.str(); | |||
951 | return createError( | |||
952 | "unable to get section index for symbol with st_shndx = 0x" + | |||
953 | Twine::utohexstr(Ndx) + " (" + Desc + ")"); | |||
954 | }; | |||
955 | ||||
956 | if (Ndx >= ELF::SHN_LOPROC && Ndx <= ELF::SHN_HIPROC) | |||
957 | return CreateErr("SHN_LOPROC", Ndx - ELF::SHN_LOPROC); | |||
958 | if (Ndx >= ELF::SHN_LOOS && Ndx <= ELF::SHN_HIOS) | |||
959 | return CreateErr("SHN_LOOS", Ndx - ELF::SHN_LOOS); | |||
960 | if (Ndx == ELF::SHN_UNDEF) | |||
961 | return CreateErr("SHN_UNDEF"); | |||
962 | if (Ndx == ELF::SHN_ABS) | |||
963 | return CreateErr("SHN_ABS"); | |||
964 | if (Ndx == ELF::SHN_COMMON) | |||
965 | return CreateErr("SHN_COMMON"); | |||
966 | return CreateErr("SHN_LORESERVE", Ndx - SHN_LORESERVE); | |||
967 | } | |||
968 | ||||
969 | template <typename ELFT> | |||
970 | Expected<StringRef> | |||
971 | ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym &Symbol, | |||
972 | unsigned SectionIndex) const { | |||
973 | Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(SectionIndex); | |||
974 | if (!SecOrErr) | |||
975 | return SecOrErr.takeError(); | |||
976 | return Obj.getSectionName(**SecOrErr); | |||
977 | } | |||
978 | ||||
979 | template <class ELFO> | |||
980 | static const typename ELFO::Elf_Shdr * | |||
981 | findNotEmptySectionByAddress(const ELFO &Obj, StringRef FileName, | |||
982 | uint64_t Addr) { | |||
983 | for (const typename ELFO::Elf_Shdr &Shdr : cantFail(Obj.sections())) | |||
984 | if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) | |||
985 | return &Shdr; | |||
986 | return nullptr; | |||
987 | } | |||
988 | ||||
989 | const EnumEntry<unsigned> ElfClass[] = { | |||
990 | {"None", "none", ELF::ELFCLASSNONE}, | |||
991 | {"32-bit", "ELF32", ELF::ELFCLASS32}, | |||
992 | {"64-bit", "ELF64", ELF::ELFCLASS64}, | |||
993 | }; | |||
994 | ||||
995 | const EnumEntry<unsigned> ElfDataEncoding[] = { | |||
996 | {"None", "none", ELF::ELFDATANONE}, | |||
997 | {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, | |||
998 | {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, | |||
999 | }; | |||
1000 | ||||
1001 | const EnumEntry<unsigned> ElfObjectFileType[] = { | |||
1002 | {"None", "NONE (none)", ELF::ET_NONE}, | |||
1003 | {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, | |||
1004 | {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, | |||
1005 | {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, | |||
1006 | {"Core", "CORE (Core file)", ELF::ET_CORE}, | |||
1007 | }; | |||
1008 | ||||
1009 | const EnumEntry<unsigned> ElfOSABI[] = { | |||
1010 | {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, | |||
1011 | {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, | |||
1012 | {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, | |||
1013 | {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, | |||
1014 | {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, | |||
1015 | {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, | |||
1016 | {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, | |||
1017 | {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, | |||
1018 | {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, | |||
1019 | {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, | |||
1020 | {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, | |||
1021 | {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, | |||
1022 | {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, | |||
1023 | {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, | |||
1024 | {"AROS", "AROS", ELF::ELFOSABI_AROS}, | |||
1025 | {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, | |||
1026 | {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, | |||
1027 | {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} | |||
1028 | }; | |||
1029 | ||||
1030 | const EnumEntry<unsigned> AMDGPUElfOSABI[] = { | |||
1031 | {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA}, | |||
1032 | {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}, | |||
1033 | {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D} | |||
1034 | }; | |||
1035 | ||||
1036 | const EnumEntry<unsigned> ARMElfOSABI[] = { | |||
1037 | {"ARM", "ARM", ELF::ELFOSABI_ARM} | |||
1038 | }; | |||
1039 | ||||
1040 | const EnumEntry<unsigned> C6000ElfOSABI[] = { | |||
1041 | {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, | |||
1042 | {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX} | |||
1043 | }; | |||
1044 | ||||
1045 | const EnumEntry<unsigned> ElfMachineType[] = { | |||
1046 | ENUM_ENT(EM_NONE, "None"){ "EM_NONE", "None", ELF::EM_NONE }, | |||
1047 | ENUM_ENT(EM_M32, "WE32100"){ "EM_M32", "WE32100", ELF::EM_M32 }, | |||
1048 | ENUM_ENT(EM_SPARC, "Sparc"){ "EM_SPARC", "Sparc", ELF::EM_SPARC }, | |||
1049 | ENUM_ENT(EM_386, "Intel 80386"){ "EM_386", "Intel 80386", ELF::EM_386 }, | |||
1050 | ENUM_ENT(EM_68K, "MC68000"){ "EM_68K", "MC68000", ELF::EM_68K }, | |||
1051 | ENUM_ENT(EM_88K, "MC88000"){ "EM_88K", "MC88000", ELF::EM_88K }, | |||
1052 | ENUM_ENT(EM_IAMCU, "EM_IAMCU"){ "EM_IAMCU", "EM_IAMCU", ELF::EM_IAMCU }, | |||
1053 | ENUM_ENT(EM_860, "Intel 80860"){ "EM_860", "Intel 80860", ELF::EM_860 }, | |||
1054 | ENUM_ENT(EM_MIPS, "MIPS R3000"){ "EM_MIPS", "MIPS R3000", ELF::EM_MIPS }, | |||
1055 | ENUM_ENT(EM_S370, "IBM System/370"){ "EM_S370", "IBM System/370", ELF::EM_S370 }, | |||
1056 | ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"){ "EM_MIPS_RS3_LE", "MIPS R3000 little-endian", ELF::EM_MIPS_RS3_LE }, | |||
1057 | ENUM_ENT(EM_PARISC, "HPPA"){ "EM_PARISC", "HPPA", ELF::EM_PARISC }, | |||
1058 | ENUM_ENT(EM_VPP500, "Fujitsu VPP500"){ "EM_VPP500", "Fujitsu VPP500", ELF::EM_VPP500 }, | |||
1059 | ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"){ "EM_SPARC32PLUS", "Sparc v8+", ELF::EM_SPARC32PLUS }, | |||
1060 | ENUM_ENT(EM_960, "Intel 80960"){ "EM_960", "Intel 80960", ELF::EM_960 }, | |||
1061 | ENUM_ENT(EM_PPC, "PowerPC"){ "EM_PPC", "PowerPC", ELF::EM_PPC }, | |||
1062 | ENUM_ENT(EM_PPC64, "PowerPC64"){ "EM_PPC64", "PowerPC64", ELF::EM_PPC64 }, | |||
1063 | ENUM_ENT(EM_S390, "IBM S/390"){ "EM_S390", "IBM S/390", ELF::EM_S390 }, | |||
1064 | ENUM_ENT(EM_SPU, "SPU"){ "EM_SPU", "SPU", ELF::EM_SPU }, | |||
1065 | ENUM_ENT(EM_V800, "NEC V800 series"){ "EM_V800", "NEC V800 series", ELF::EM_V800 }, | |||
1066 | ENUM_ENT(EM_FR20, "Fujistsu FR20"){ "EM_FR20", "Fujistsu FR20", ELF::EM_FR20 }, | |||
1067 | ENUM_ENT(EM_RH32, "TRW RH-32"){ "EM_RH32", "TRW RH-32", ELF::EM_RH32 }, | |||
1068 | ENUM_ENT(EM_RCE, "Motorola RCE"){ "EM_RCE", "Motorola RCE", ELF::EM_RCE }, | |||
1069 | ENUM_ENT(EM_ARM, "ARM"){ "EM_ARM", "ARM", ELF::EM_ARM }, | |||
1070 | ENUM_ENT(EM_ALPHA, "EM_ALPHA"){ "EM_ALPHA", "EM_ALPHA", ELF::EM_ALPHA }, | |||
1071 | ENUM_ENT(EM_SH, "Hitachi SH"){ "EM_SH", "Hitachi SH", ELF::EM_SH }, | |||
1072 | ENUM_ENT(EM_SPARCV9, "Sparc v9"){ "EM_SPARCV9", "Sparc v9", ELF::EM_SPARCV9 }, | |||
1073 | ENUM_ENT(EM_TRICORE, "Siemens Tricore"){ "EM_TRICORE", "Siemens Tricore", ELF::EM_TRICORE }, | |||
1074 | ENUM_ENT(EM_ARC, "ARC"){ "EM_ARC", "ARC", ELF::EM_ARC }, | |||
1075 | ENUM_ENT(EM_H8_300, "Hitachi H8/300"){ "EM_H8_300", "Hitachi H8/300", ELF::EM_H8_300 }, | |||
1076 | ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"){ "EM_H8_300H", "Hitachi H8/300H", ELF::EM_H8_300H }, | |||
1077 | ENUM_ENT(EM_H8S, "Hitachi H8S"){ "EM_H8S", "Hitachi H8S", ELF::EM_H8S }, | |||
1078 | ENUM_ENT(EM_H8_500, "Hitachi H8/500"){ "EM_H8_500", "Hitachi H8/500", ELF::EM_H8_500 }, | |||
1079 | ENUM_ENT(EM_IA_64, "Intel IA-64"){ "EM_IA_64", "Intel IA-64", ELF::EM_IA_64 }, | |||
1080 | ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"){ "EM_MIPS_X", "Stanford MIPS-X", ELF::EM_MIPS_X }, | |||
1081 | ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"){ "EM_COLDFIRE", "Motorola Coldfire", ELF::EM_COLDFIRE }, | |||
1082 | ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"){ "EM_68HC12", "Motorola MC68HC12 Microcontroller", ELF::EM_68HC12 }, | |||
1083 | ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"){ "EM_MMA", "Fujitsu Multimedia Accelerator", ELF::EM_MMA }, | |||
1084 | ENUM_ENT(EM_PCP, "Siemens PCP"){ "EM_PCP", "Siemens PCP", ELF::EM_PCP }, | |||
1085 | ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"){ "EM_NCPU", "Sony nCPU embedded RISC processor", ELF::EM_NCPU }, | |||
1086 | ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"){ "EM_NDR1", "Denso NDR1 microprocesspr", ELF::EM_NDR1 }, | |||
1087 | ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"){ "EM_STARCORE", "Motorola Star*Core processor", ELF::EM_STARCORE }, | |||
1088 | ENUM_ENT(EM_ME16, "Toyota ME16 processor"){ "EM_ME16", "Toyota ME16 processor", ELF::EM_ME16 }, | |||
1089 | ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"){ "EM_ST100", "STMicroelectronics ST100 processor", ELF::EM_ST100 }, | |||
1090 | ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"){ "EM_TINYJ", "Advanced Logic Corp. TinyJ embedded processor" , ELF::EM_TINYJ }, | |||
1091 | ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"){ "EM_X86_64", "Advanced Micro Devices X86-64", ELF::EM_X86_64 }, | |||
1092 | ENUM_ENT(EM_PDSP, "Sony DSP processor"){ "EM_PDSP", "Sony DSP processor", ELF::EM_PDSP }, | |||
1093 | ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"){ "EM_PDP10", "Digital Equipment Corp. PDP-10", ELF::EM_PDP10 }, | |||
1094 | ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"){ "EM_PDP11", "Digital Equipment Corp. PDP-11", ELF::EM_PDP11 }, | |||
1095 | ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"){ "EM_FX66", "Siemens FX66 microcontroller", ELF::EM_FX66 }, | |||
1096 | ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"){ "EM_ST9PLUS", "STMicroelectronics ST9+ 8/16 bit microcontroller" , ELF::EM_ST9PLUS }, | |||
1097 | ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"){ "EM_ST7", "STMicroelectronics ST7 8-bit microcontroller", ELF ::EM_ST7 }, | |||
1098 | ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"){ "EM_68HC16", "Motorola MC68HC16 Microcontroller", ELF::EM_68HC16 }, | |||
1099 | ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"){ "EM_68HC11", "Motorola MC68HC11 Microcontroller", ELF::EM_68HC11 }, | |||
1100 | ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"){ "EM_68HC08", "Motorola MC68HC08 Microcontroller", ELF::EM_68HC08 }, | |||
1101 | ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"){ "EM_68HC05", "Motorola MC68HC05 Microcontroller", ELF::EM_68HC05 }, | |||
1102 | ENUM_ENT(EM_SVX, "Silicon Graphics SVx"){ "EM_SVX", "Silicon Graphics SVx", ELF::EM_SVX }, | |||
1103 | ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"){ "EM_ST19", "STMicroelectronics ST19 8-bit microcontroller", ELF::EM_ST19 }, | |||
1104 | ENUM_ENT(EM_VAX, "Digital VAX"){ "EM_VAX", "Digital VAX", ELF::EM_VAX }, | |||
1105 | ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"){ "EM_CRIS", "Axis Communications 32-bit embedded processor", ELF::EM_CRIS }, | |||
1106 | ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"){ "EM_JAVELIN", "Infineon Technologies 32-bit embedded cpu", ELF ::EM_JAVELIN }, | |||
1107 | ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"){ "EM_FIREPATH", "Element 14 64-bit DSP processor", ELF::EM_FIREPATH }, | |||
1108 | ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"){ "EM_ZSP", "LSI Logic's 16-bit DSP processor", ELF::EM_ZSP }, | |||
1109 | ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"){ "EM_MMIX", "Donald Knuth's educational 64-bit processor", ELF ::EM_MMIX }, | |||
1110 | ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"){ "EM_HUANY", "Harvard Universitys's machine-independent object format" , ELF::EM_HUANY }, | |||
1111 | ENUM_ENT(EM_PRISM, "Vitesse Prism"){ "EM_PRISM", "Vitesse Prism", ELF::EM_PRISM }, | |||
1112 | ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"){ "EM_AVR", "Atmel AVR 8-bit microcontroller", ELF::EM_AVR }, | |||
1113 | ENUM_ENT(EM_FR30, "Fujitsu FR30"){ "EM_FR30", "Fujitsu FR30", ELF::EM_FR30 }, | |||
1114 | ENUM_ENT(EM_D10V, "Mitsubishi D10V"){ "EM_D10V", "Mitsubishi D10V", ELF::EM_D10V }, | |||
1115 | ENUM_ENT(EM_D30V, "Mitsubishi D30V"){ "EM_D30V", "Mitsubishi D30V", ELF::EM_D30V }, | |||
1116 | ENUM_ENT(EM_V850, "NEC v850"){ "EM_V850", "NEC v850", ELF::EM_V850 }, | |||
1117 | ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"){ "EM_M32R", "Renesas M32R (formerly Mitsubishi M32r)", ELF:: EM_M32R }, | |||
1118 | ENUM_ENT(EM_MN10300, "Matsushita MN10300"){ "EM_MN10300", "Matsushita MN10300", ELF::EM_MN10300 }, | |||
1119 | ENUM_ENT(EM_MN10200, "Matsushita MN10200"){ "EM_MN10200", "Matsushita MN10200", ELF::EM_MN10200 }, | |||
1120 | ENUM_ENT(EM_PJ, "picoJava"){ "EM_PJ", "picoJava", ELF::EM_PJ }, | |||
1121 | ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"){ "EM_OPENRISC", "OpenRISC 32-bit embedded processor", ELF::EM_OPENRISC }, | |||
1122 | ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"){ "EM_ARC_COMPACT", "EM_ARC_COMPACT", ELF::EM_ARC_COMPACT }, | |||
1123 | ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"){ "EM_XTENSA", "Tensilica Xtensa Processor", ELF::EM_XTENSA }, | |||
1124 | ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"){ "EM_VIDEOCORE", "Alphamosaic VideoCore processor", ELF::EM_VIDEOCORE }, | |||
1125 | ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"){ "EM_TMM_GPP", "Thompson Multimedia General Purpose Processor" , ELF::EM_TMM_GPP }, | |||
1126 | ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"){ "EM_NS32K", "National Semiconductor 32000 series", ELF::EM_NS32K }, | |||
1127 | ENUM_ENT(EM_TPC, "Tenor Network TPC processor"){ "EM_TPC", "Tenor Network TPC processor", ELF::EM_TPC }, | |||
1128 | ENUM_ENT(EM_SNP1K, "EM_SNP1K"){ "EM_SNP1K", "EM_SNP1K", ELF::EM_SNP1K }, | |||
1129 | ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"){ "EM_ST200", "STMicroelectronics ST200 microcontroller", ELF ::EM_ST200 }, | |||
1130 | ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"){ "EM_IP2K", "Ubicom IP2xxx 8-bit microcontrollers", ELF::EM_IP2K }, | |||
1131 | ENUM_ENT(EM_MAX, "MAX Processor"){ "EM_MAX", "MAX Processor", ELF::EM_MAX }, | |||
1132 | ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"){ "EM_CR", "National Semiconductor CompactRISC", ELF::EM_CR }, | |||
1133 | ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"){ "EM_F2MC16", "Fujitsu F2MC16", ELF::EM_F2MC16 }, | |||
1134 | ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"){ "EM_MSP430", "Texas Instruments msp430 microcontroller", ELF ::EM_MSP430 }, | |||
1135 | ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"){ "EM_BLACKFIN", "Analog Devices Blackfin", ELF::EM_BLACKFIN }, | |||
1136 | ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"){ "EM_SE_C33", "S1C33 Family of Seiko Epson processors", ELF:: EM_SE_C33 }, | |||
1137 | ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"){ "EM_SEP", "Sharp embedded microprocessor", ELF::EM_SEP }, | |||
1138 | ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"){ "EM_ARCA", "Arca RISC microprocessor", ELF::EM_ARCA }, | |||
1139 | ENUM_ENT(EM_UNICORE, "Unicore"){ "EM_UNICORE", "Unicore", ELF::EM_UNICORE }, | |||
1140 | 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 }, | |||
1141 | ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"){ "EM_DXP", "Icera Semiconductor Inc. Deep Execution Processor" , ELF::EM_DXP }, | |||
1142 | ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"){ "EM_ALTERA_NIOS2", "Altera Nios", ELF::EM_ALTERA_NIOS2 }, | |||
1143 | ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"){ "EM_CRX", "National Semiconductor CRX microprocessor", ELF:: EM_CRX }, | |||
1144 | ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"){ "EM_XGATE", "Motorola XGATE embedded processor", ELF::EM_XGATE }, | |||
1145 | ENUM_ENT(EM_C166, "Infineon Technologies xc16x"){ "EM_C166", "Infineon Technologies xc16x", ELF::EM_C166 }, | |||
1146 | ENUM_ENT(EM_M16C, "Renesas M16C"){ "EM_M16C", "Renesas M16C", ELF::EM_M16C }, | |||
1147 | ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"){ "EM_DSPIC30F", "Microchip Technology dsPIC30F Digital Signal Controller" , ELF::EM_DSPIC30F }, | |||
1148 | ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"){ "EM_CE", "Freescale Communication Engine RISC core", ELF::EM_CE }, | |||
1149 | ENUM_ENT(EM_M32C, "Renesas M32C"){ "EM_M32C", "Renesas M32C", ELF::EM_M32C }, | |||
1150 | ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"){ "EM_TSK3000", "Altium TSK3000 core", ELF::EM_TSK3000 }, | |||
1151 | ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"){ "EM_RS08", "Freescale RS08 embedded processor", ELF::EM_RS08 }, | |||
1152 | ENUM_ENT(EM_SHARC, "EM_SHARC"){ "EM_SHARC", "EM_SHARC", ELF::EM_SHARC }, | |||
1153 | ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"){ "EM_ECOG2", "Cyan Technology eCOG2 microprocessor", ELF::EM_ECOG2 }, | |||
1154 | ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"){ "EM_SCORE7", "SUNPLUS S+Core", ELF::EM_SCORE7 }, | |||
1155 | 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 }, | |||
1156 | ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"){ "EM_VIDEOCORE3", "Broadcom VideoCore III processor", ELF::EM_VIDEOCORE3 }, | |||
1157 | ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"){ "EM_LATTICEMICO32", "Lattice Mico32", ELF::EM_LATTICEMICO32 }, | |||
1158 | ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"){ "EM_SE_C17", "Seiko Epson C17 family", ELF::EM_SE_C17 }, | |||
1159 | ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"){ "EM_TI_C6000", "Texas Instruments TMS320C6000 DSP family", ELF ::EM_TI_C6000 }, | |||
1160 | ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"){ "EM_TI_C2000", "Texas Instruments TMS320C2000 DSP family", ELF ::EM_TI_C2000 }, | |||
1161 | ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"){ "EM_TI_C5500", "Texas Instruments TMS320C55x DSP family", ELF ::EM_TI_C5500 }, | |||
1162 | ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"){ "EM_MMDSP_PLUS", "STMicroelectronics 64bit VLIW Data Signal Processor" , ELF::EM_MMDSP_PLUS }, | |||
1163 | ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"){ "EM_CYPRESS_M8C", "Cypress M8C microprocessor", ELF::EM_CYPRESS_M8C }, | |||
1164 | ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"){ "EM_R32C", "Renesas R32C series microprocessors", ELF::EM_R32C }, | |||
1165 | ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"){ "EM_TRIMEDIA", "NXP Semiconductors TriMedia architecture family" , ELF::EM_TRIMEDIA }, | |||
1166 | ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"){ "EM_HEXAGON", "Qualcomm Hexagon", ELF::EM_HEXAGON }, | |||
1167 | ENUM_ENT(EM_8051, "Intel 8051 and variants"){ "EM_8051", "Intel 8051 and variants", ELF::EM_8051 }, | |||
1168 | ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"){ "EM_STXP7X", "STMicroelectronics STxP7x family", ELF::EM_STXP7X }, | |||
1169 | 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 }, | |||
1170 | ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"){ "EM_ECOG1", "Cyan Technology eCOG1 microprocessor", ELF::EM_ECOG1 }, | |||
1171 | // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has | |||
1172 | // an identical number to EM_ECOG1. | |||
1173 | ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"){ "EM_ECOG1X", "Cyan Technology eCOG1X family", ELF::EM_ECOG1X }, | |||
1174 | ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"){ "EM_MAXQ30", "Dallas Semiconductor MAXQ30 Core microcontrollers" , ELF::EM_MAXQ30 }, | |||
1175 | 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 }, | |||
1176 | ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"){ "EM_MANIK", "M2000 Reconfigurable RISC Microprocessor", ELF ::EM_MANIK }, | |||
1177 | ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"){ "EM_CRAYNV2", "Cray Inc. NV2 vector architecture", ELF::EM_CRAYNV2 }, | |||
1178 | ENUM_ENT(EM_RX, "Renesas RX"){ "EM_RX", "Renesas RX", ELF::EM_RX }, | |||
1179 | ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"){ "EM_METAG", "Imagination Technologies Meta processor architecture" , ELF::EM_METAG }, | |||
1180 | ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"){ "EM_MCST_ELBRUS", "MCST Elbrus general purpose hardware architecture" , ELF::EM_MCST_ELBRUS }, | |||
1181 | ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"){ "EM_ECOG16", "Cyan Technology eCOG16 family", ELF::EM_ECOG16 }, | |||
1182 | ENUM_ENT(EM_CR16, "National Semiconductor CompactRISC 16-bit processor"){ "EM_CR16", "National Semiconductor CompactRISC 16-bit processor" , ELF::EM_CR16 }, | |||
1183 | ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"){ "EM_ETPU", "Freescale Extended Time Processing Unit", ELF:: EM_ETPU }, | |||
1184 | ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"){ "EM_SLE9X", "Infineon Technologies SLE9X core", ELF::EM_SLE9X }, | |||
1185 | ENUM_ENT(EM_L10M, "EM_L10M"){ "EM_L10M", "EM_L10M", ELF::EM_L10M }, | |||
1186 | ENUM_ENT(EM_K10M, "EM_K10M"){ "EM_K10M", "EM_K10M", ELF::EM_K10M }, | |||
1187 | ENUM_ENT(EM_AARCH64, "AArch64"){ "EM_AARCH64", "AArch64", ELF::EM_AARCH64 }, | |||
1188 | ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"){ "EM_AVR32", "Atmel Corporation 32-bit microprocessor family" , ELF::EM_AVR32 }, | |||
1189 | ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"){ "EM_STM8", "STMicroeletronics STM8 8-bit microcontroller", ELF ::EM_STM8 }, | |||
1190 | ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"){ "EM_TILE64", "Tilera TILE64 multicore architecture family", ELF::EM_TILE64 }, | |||
1191 | ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"){ "EM_TILEPRO", "Tilera TILEPro multicore architecture family" , ELF::EM_TILEPRO }, | |||
1192 | 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 }, | |||
1193 | ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"){ "EM_CUDA", "NVIDIA CUDA architecture", ELF::EM_CUDA }, | |||
1194 | ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"){ "EM_TILEGX", "Tilera TILE-Gx multicore architecture family" , ELF::EM_TILEGX }, | |||
1195 | ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"){ "EM_CLOUDSHIELD", "EM_CLOUDSHIELD", ELF::EM_CLOUDSHIELD }, | |||
1196 | ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"){ "EM_COREA_1ST", "EM_COREA_1ST", ELF::EM_COREA_1ST }, | |||
1197 | ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"){ "EM_COREA_2ND", "EM_COREA_2ND", ELF::EM_COREA_2ND }, | |||
1198 | ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"){ "EM_ARC_COMPACT2", "EM_ARC_COMPACT2", ELF::EM_ARC_COMPACT2 }, | |||
1199 | ENUM_ENT(EM_OPEN8, "EM_OPEN8"){ "EM_OPEN8", "EM_OPEN8", ELF::EM_OPEN8 }, | |||
1200 | ENUM_ENT(EM_RL78, "Renesas RL78"){ "EM_RL78", "Renesas RL78", ELF::EM_RL78 }, | |||
1201 | ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"){ "EM_VIDEOCORE5", "Broadcom VideoCore V processor", ELF::EM_VIDEOCORE5 }, | |||
1202 | ENUM_ENT(EM_78KOR, "EM_78KOR"){ "EM_78KOR", "EM_78KOR", ELF::EM_78KOR }, | |||
1203 | ENUM_ENT(EM_56800EX, "EM_56800EX"){ "EM_56800EX", "EM_56800EX", ELF::EM_56800EX }, | |||
1204 | ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"){ "EM_AMDGPU", "EM_AMDGPU", ELF::EM_AMDGPU }, | |||
1205 | ENUM_ENT(EM_RISCV, "RISC-V"){ "EM_RISCV", "RISC-V", ELF::EM_RISCV }, | |||
1206 | ENUM_ENT(EM_LANAI, "EM_LANAI"){ "EM_LANAI", "EM_LANAI", ELF::EM_LANAI }, | |||
1207 | ENUM_ENT(EM_BPF, "EM_BPF"){ "EM_BPF", "EM_BPF", ELF::EM_BPF }, | |||
1208 | ENUM_ENT(EM_VE, "NEC SX-Aurora Vector Engine"){ "EM_VE", "NEC SX-Aurora Vector Engine", ELF::EM_VE }, | |||
1209 | ENUM_ENT(EM_LOONGARCH, "LoongArch"){ "EM_LOONGARCH", "LoongArch", ELF::EM_LOONGARCH }, | |||
1210 | }; | |||
1211 | ||||
1212 | const EnumEntry<unsigned> ElfSymbolBindings[] = { | |||
1213 | {"Local", "LOCAL", ELF::STB_LOCAL}, | |||
1214 | {"Global", "GLOBAL", ELF::STB_GLOBAL}, | |||
1215 | {"Weak", "WEAK", ELF::STB_WEAK}, | |||
1216 | {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; | |||
1217 | ||||
1218 | const EnumEntry<unsigned> ElfSymbolVisibilities[] = { | |||
1219 | {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, | |||
1220 | {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, | |||
1221 | {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, | |||
1222 | {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; | |||
1223 | ||||
1224 | const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { | |||
1225 | { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL } | |||
1226 | }; | |||
1227 | ||||
1228 | static const char *getGroupType(uint32_t Flag) { | |||
1229 | if (Flag & ELF::GRP_COMDAT) | |||
1230 | return "COMDAT"; | |||
1231 | else | |||
1232 | return "(unknown)"; | |||
1233 | } | |||
1234 | ||||
1235 | const EnumEntry<unsigned> ElfSectionFlags[] = { | |||
1236 | ENUM_ENT(SHF_WRITE, "W"){ "SHF_WRITE", "W", ELF::SHF_WRITE }, | |||
1237 | ENUM_ENT(SHF_ALLOC, "A"){ "SHF_ALLOC", "A", ELF::SHF_ALLOC }, | |||
1238 | ENUM_ENT(SHF_EXECINSTR, "X"){ "SHF_EXECINSTR", "X", ELF::SHF_EXECINSTR }, | |||
1239 | ENUM_ENT(SHF_MERGE, "M"){ "SHF_MERGE", "M", ELF::SHF_MERGE }, | |||
1240 | ENUM_ENT(SHF_STRINGS, "S"){ "SHF_STRINGS", "S", ELF::SHF_STRINGS }, | |||
1241 | ENUM_ENT(SHF_INFO_LINK, "I"){ "SHF_INFO_LINK", "I", ELF::SHF_INFO_LINK }, | |||
1242 | ENUM_ENT(SHF_LINK_ORDER, "L"){ "SHF_LINK_ORDER", "L", ELF::SHF_LINK_ORDER }, | |||
1243 | ENUM_ENT(SHF_OS_NONCONFORMING, "O"){ "SHF_OS_NONCONFORMING", "O", ELF::SHF_OS_NONCONFORMING }, | |||
1244 | ENUM_ENT(SHF_GROUP, "G"){ "SHF_GROUP", "G", ELF::SHF_GROUP }, | |||
1245 | ENUM_ENT(SHF_TLS, "T"){ "SHF_TLS", "T", ELF::SHF_TLS }, | |||
1246 | ENUM_ENT(SHF_COMPRESSED, "C"){ "SHF_COMPRESSED", "C", ELF::SHF_COMPRESSED }, | |||
1247 | ENUM_ENT(SHF_EXCLUDE, "E"){ "SHF_EXCLUDE", "E", ELF::SHF_EXCLUDE }, | |||
1248 | }; | |||
1249 | ||||
1250 | const EnumEntry<unsigned> ElfGNUSectionFlags[] = { | |||
1251 | ENUM_ENT(SHF_GNU_RETAIN, "R"){ "SHF_GNU_RETAIN", "R", ELF::SHF_GNU_RETAIN } | |||
1252 | }; | |||
1253 | ||||
1254 | const EnumEntry<unsigned> ElfSolarisSectionFlags[] = { | |||
1255 | ENUM_ENT(SHF_SUNW_NODISCARD, "R"){ "SHF_SUNW_NODISCARD", "R", ELF::SHF_SUNW_NODISCARD } | |||
1256 | }; | |||
1257 | ||||
1258 | const EnumEntry<unsigned> ElfXCoreSectionFlags[] = { | |||
1259 | ENUM_ENT(XCORE_SHF_CP_SECTION, ""){ "XCORE_SHF_CP_SECTION", "", ELF::XCORE_SHF_CP_SECTION }, | |||
1260 | ENUM_ENT(XCORE_SHF_DP_SECTION, ""){ "XCORE_SHF_DP_SECTION", "", ELF::XCORE_SHF_DP_SECTION } | |||
1261 | }; | |||
1262 | ||||
1263 | const EnumEntry<unsigned> ElfARMSectionFlags[] = { | |||
1264 | ENUM_ENT(SHF_ARM_PURECODE, "y"){ "SHF_ARM_PURECODE", "y", ELF::SHF_ARM_PURECODE } | |||
1265 | }; | |||
1266 | ||||
1267 | const EnumEntry<unsigned> ElfHexagonSectionFlags[] = { | |||
1268 | ENUM_ENT(SHF_HEX_GPREL, ""){ "SHF_HEX_GPREL", "", ELF::SHF_HEX_GPREL } | |||
1269 | }; | |||
1270 | ||||
1271 | const EnumEntry<unsigned> ElfMipsSectionFlags[] = { | |||
1272 | ENUM_ENT(SHF_MIPS_NODUPES, ""){ "SHF_MIPS_NODUPES", "", ELF::SHF_MIPS_NODUPES }, | |||
1273 | ENUM_ENT(SHF_MIPS_NAMES, ""){ "SHF_MIPS_NAMES", "", ELF::SHF_MIPS_NAMES }, | |||
1274 | ENUM_ENT(SHF_MIPS_LOCAL, ""){ "SHF_MIPS_LOCAL", "", ELF::SHF_MIPS_LOCAL }, | |||
1275 | ENUM_ENT(SHF_MIPS_NOSTRIP, ""){ "SHF_MIPS_NOSTRIP", "", ELF::SHF_MIPS_NOSTRIP }, | |||
1276 | ENUM_ENT(SHF_MIPS_GPREL, ""){ "SHF_MIPS_GPREL", "", ELF::SHF_MIPS_GPREL }, | |||
1277 | ENUM_ENT(SHF_MIPS_MERGE, ""){ "SHF_MIPS_MERGE", "", ELF::SHF_MIPS_MERGE }, | |||
1278 | ENUM_ENT(SHF_MIPS_ADDR, ""){ "SHF_MIPS_ADDR", "", ELF::SHF_MIPS_ADDR }, | |||
1279 | ENUM_ENT(SHF_MIPS_STRING, ""){ "SHF_MIPS_STRING", "", ELF::SHF_MIPS_STRING } | |||
1280 | }; | |||
1281 | ||||
1282 | const EnumEntry<unsigned> ElfX86_64SectionFlags[] = { | |||
1283 | ENUM_ENT(SHF_X86_64_LARGE, "l"){ "SHF_X86_64_LARGE", "l", ELF::SHF_X86_64_LARGE } | |||
1284 | }; | |||
1285 | ||||
1286 | static std::vector<EnumEntry<unsigned>> | |||
1287 | getSectionFlagsForTarget(unsigned EOSAbi, unsigned EMachine) { | |||
1288 | std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags), | |||
1289 | std::end(ElfSectionFlags)); | |||
1290 | switch (EOSAbi) { | |||
1291 | case ELFOSABI_SOLARIS: | |||
1292 | Ret.insert(Ret.end(), std::begin(ElfSolarisSectionFlags), | |||
1293 | std::end(ElfSolarisSectionFlags)); | |||
1294 | break; | |||
1295 | default: | |||
1296 | Ret.insert(Ret.end(), std::begin(ElfGNUSectionFlags), | |||
1297 | std::end(ElfGNUSectionFlags)); | |||
1298 | break; | |||
1299 | } | |||
1300 | switch (EMachine) { | |||
1301 | case EM_ARM: | |||
1302 | Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags), | |||
1303 | std::end(ElfARMSectionFlags)); | |||
1304 | break; | |||
1305 | case EM_HEXAGON: | |||
1306 | Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags), | |||
1307 | std::end(ElfHexagonSectionFlags)); | |||
1308 | break; | |||
1309 | case EM_MIPS: | |||
1310 | Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags), | |||
1311 | std::end(ElfMipsSectionFlags)); | |||
1312 | break; | |||
1313 | case EM_X86_64: | |||
1314 | Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags), | |||
1315 | std::end(ElfX86_64SectionFlags)); | |||
1316 | break; | |||
1317 | case EM_XCORE: | |||
1318 | Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags), | |||
1319 | std::end(ElfXCoreSectionFlags)); | |||
1320 | break; | |||
1321 | default: | |||
1322 | break; | |||
1323 | } | |||
1324 | return Ret; | |||
1325 | } | |||
1326 | ||||
1327 | static std::string getGNUFlags(unsigned EOSAbi, unsigned EMachine, | |||
1328 | uint64_t Flags) { | |||
1329 | // Here we are trying to build the flags string in the same way as GNU does. | |||
1330 | // It is not that straightforward. Imagine we have sh_flags == 0x90000000. | |||
1331 | // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000. | |||
1332 | // GNU readelf will not print "E" or "Ep" in this case, but will print just | |||
1333 | // "p". It only will print "E" when no other processor flag is set. | |||
1334 | std::string Str; | |||
1335 | bool HasUnknownFlag = false; | |||
1336 | bool HasOSFlag = false; | |||
1337 | bool HasProcFlag = false; | |||
1338 | std::vector<EnumEntry<unsigned>> FlagsList = | |||
1339 | getSectionFlagsForTarget(EOSAbi, EMachine); | |||
1340 | while (Flags) { | |||
1341 | // Take the least significant bit as a flag. | |||
1342 | uint64_t Flag = Flags & -Flags; | |||
1343 | Flags -= Flag; | |||
1344 | ||||
1345 | // Find the flag in the known flags list. | |||
1346 | auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) { | |||
1347 | // Flags with empty names are not printed in GNU style output. | |||
1348 | return E.Value == Flag && !E.AltName.empty(); | |||
1349 | }); | |||
1350 | if (I != FlagsList.end()) { | |||
1351 | Str += I->AltName; | |||
1352 | continue; | |||
1353 | } | |||
1354 | ||||
1355 | // If we did not find a matching regular flag, then we deal with an OS | |||
1356 | // specific flag, processor specific flag or an unknown flag. | |||
1357 | if (Flag & ELF::SHF_MASKOS) { | |||
1358 | HasOSFlag = true; | |||
1359 | Flags &= ~ELF::SHF_MASKOS; | |||
1360 | } else if (Flag & ELF::SHF_MASKPROC) { | |||
1361 | HasProcFlag = true; | |||
1362 | // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE | |||
1363 | // bit if set so that it doesn't also get printed. | |||
1364 | Flags &= ~ELF::SHF_MASKPROC; | |||
1365 | } else { | |||
1366 | HasUnknownFlag = true; | |||
1367 | } | |||
1368 | } | |||
1369 | ||||
1370 | // "o", "p" and "x" are printed last. | |||
1371 | if (HasOSFlag) | |||
1372 | Str += "o"; | |||
1373 | if (HasProcFlag) | |||
1374 | Str += "p"; | |||
1375 | if (HasUnknownFlag) | |||
1376 | Str += "x"; | |||
1377 | return Str; | |||
1378 | } | |||
1379 | ||||
1380 | static StringRef segmentTypeToString(unsigned Arch, unsigned Type) { | |||
1381 | // Check potentially overlapped processor-specific program header type. | |||
1382 | switch (Arch) { | |||
1383 | case ELF::EM_ARM: | |||
1384 | switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX)case ELF::PT_ARM_EXIDX: return "PT_ARM_EXIDX";; } | |||
1385 | break; | |||
1386 | case ELF::EM_MIPS: | |||
1387 | case ELF::EM_MIPS_RS3_LE: | |||
1388 | switch (Type) { | |||
1389 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO)case ELF::PT_MIPS_REGINFO: return "PT_MIPS_REGINFO";; | |||
1390 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC)case ELF::PT_MIPS_RTPROC: return "PT_MIPS_RTPROC";; | |||
1391 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS)case ELF::PT_MIPS_OPTIONS: return "PT_MIPS_OPTIONS";; | |||
1392 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS)case ELF::PT_MIPS_ABIFLAGS: return "PT_MIPS_ABIFLAGS";; | |||
1393 | } | |||
1394 | break; | |||
1395 | case ELF::EM_RISCV: | |||
1396 | switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_RISCV_ATTRIBUTES)case ELF::PT_RISCV_ATTRIBUTES: return "PT_RISCV_ATTRIBUTES";; } | |||
1397 | } | |||
1398 | ||||
1399 | switch (Type) { | |||
1400 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL)case ELF::PT_NULL: return "PT_NULL";; | |||
1401 | LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD)case ELF::PT_LOAD: return "PT_LOAD";; | |||
1402 | LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC)case ELF::PT_DYNAMIC: return "PT_DYNAMIC";; | |||
1403 | LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP)case ELF::PT_INTERP: return "PT_INTERP";; | |||
1404 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE)case ELF::PT_NOTE: return "PT_NOTE";; | |||
1405 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB)case ELF::PT_SHLIB: return "PT_SHLIB";; | |||
1406 | LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR)case ELF::PT_PHDR: return "PT_PHDR";; | |||
1407 | LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS)case ELF::PT_TLS: return "PT_TLS";; | |||
1408 | ||||
1409 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME)case ELF::PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME";; | |||
1410 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND)case ELF::PT_SUNW_UNWIND: return "PT_SUNW_UNWIND";; | |||
1411 | ||||
1412 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK)case ELF::PT_GNU_STACK: return "PT_GNU_STACK";; | |||
1413 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO)case ELF::PT_GNU_RELRO: return "PT_GNU_RELRO";; | |||
1414 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_PROPERTY)case ELF::PT_GNU_PROPERTY: return "PT_GNU_PROPERTY";; | |||
1415 | ||||
1416 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_MUTABLE)case ELF::PT_OPENBSD_MUTABLE: return "PT_OPENBSD_MUTABLE";; | |||
1417 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE)case ELF::PT_OPENBSD_RANDOMIZE: return "PT_OPENBSD_RANDOMIZE" ;; | |||
1418 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED)case ELF::PT_OPENBSD_WXNEEDED: return "PT_OPENBSD_WXNEEDED";; | |||
1419 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA)case ELF::PT_OPENBSD_BOOTDATA: return "PT_OPENBSD_BOOTDATA";; | |||
1420 | default: | |||
1421 | return ""; | |||
1422 | } | |||
1423 | } | |||
1424 | ||||
1425 | static std::string getGNUPtType(unsigned Arch, unsigned Type) { | |||
1426 | StringRef Seg = segmentTypeToString(Arch, Type); | |||
1427 | if (Seg.empty()) | |||
1428 | return std::string("<unknown>: ") + to_string(format_hex(Type, 1)); | |||
1429 | ||||
1430 | // E.g. "PT_ARM_EXIDX" -> "EXIDX". | |||
1431 | if (Seg.consume_front("PT_ARM_")) | |||
1432 | return Seg.str(); | |||
1433 | ||||
1434 | // E.g. "PT_MIPS_REGINFO" -> "REGINFO". | |||
1435 | if (Seg.consume_front("PT_MIPS_")) | |||
1436 | return Seg.str(); | |||
1437 | ||||
1438 | // E.g. "PT_RISCV_ATTRIBUTES" | |||
1439 | if (Seg.consume_front("PT_RISCV_")) | |||
1440 | return Seg.str(); | |||
1441 | ||||
1442 | // E.g. "PT_LOAD" -> "LOAD". | |||
1443 | assert(Seg.startswith("PT_"))(static_cast <bool> (Seg.startswith("PT_")) ? void (0) : __assert_fail ("Seg.startswith(\"PT_\")", "llvm/tools/llvm-readobj/ELFDumper.cpp" , 1443, __extension__ __PRETTY_FUNCTION__)); | |||
1444 | return Seg.drop_front(3).str(); | |||
1445 | } | |||
1446 | ||||
1447 | const EnumEntry<unsigned> ElfSegmentFlags[] = { | |||
1448 | LLVM_READOBJ_ENUM_ENT(ELF, PF_X){ "PF_X", ELF::PF_X }, | |||
1449 | LLVM_READOBJ_ENUM_ENT(ELF, PF_W){ "PF_W", ELF::PF_W }, | |||
1450 | LLVM_READOBJ_ENUM_ENT(ELF, PF_R){ "PF_R", ELF::PF_R } | |||
1451 | }; | |||
1452 | ||||
1453 | const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { | |||
1454 | ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"){ "EF_MIPS_NOREORDER", "noreorder", ELF::EF_MIPS_NOREORDER }, | |||
1455 | ENUM_ENT(EF_MIPS_PIC, "pic"){ "EF_MIPS_PIC", "pic", ELF::EF_MIPS_PIC }, | |||
1456 | ENUM_ENT(EF_MIPS_CPIC, "cpic"){ "EF_MIPS_CPIC", "cpic", ELF::EF_MIPS_CPIC }, | |||
1457 | ENUM_ENT(EF_MIPS_ABI2, "abi2"){ "EF_MIPS_ABI2", "abi2", ELF::EF_MIPS_ABI2 }, | |||
1458 | ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"){ "EF_MIPS_32BITMODE", "32bitmode", ELF::EF_MIPS_32BITMODE }, | |||
1459 | ENUM_ENT(EF_MIPS_FP64, "fp64"){ "EF_MIPS_FP64", "fp64", ELF::EF_MIPS_FP64 }, | |||
1460 | ENUM_ENT(EF_MIPS_NAN2008, "nan2008"){ "EF_MIPS_NAN2008", "nan2008", ELF::EF_MIPS_NAN2008 }, | |||
1461 | ENUM_ENT(EF_MIPS_ABI_O32, "o32"){ "EF_MIPS_ABI_O32", "o32", ELF::EF_MIPS_ABI_O32 }, | |||
1462 | ENUM_ENT(EF_MIPS_ABI_O64, "o64"){ "EF_MIPS_ABI_O64", "o64", ELF::EF_MIPS_ABI_O64 }, | |||
1463 | ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"){ "EF_MIPS_ABI_EABI32", "eabi32", ELF::EF_MIPS_ABI_EABI32 }, | |||
1464 | ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"){ "EF_MIPS_ABI_EABI64", "eabi64", ELF::EF_MIPS_ABI_EABI64 }, | |||
1465 | ENUM_ENT(EF_MIPS_MACH_3900, "3900"){ "EF_MIPS_MACH_3900", "3900", ELF::EF_MIPS_MACH_3900 }, | |||
1466 | ENUM_ENT(EF_MIPS_MACH_4010, "4010"){ "EF_MIPS_MACH_4010", "4010", ELF::EF_MIPS_MACH_4010 }, | |||
1467 | ENUM_ENT(EF_MIPS_MACH_4100, "4100"){ "EF_MIPS_MACH_4100", "4100", ELF::EF_MIPS_MACH_4100 }, | |||
1468 | ENUM_ENT(EF_MIPS_MACH_4650, "4650"){ "EF_MIPS_MACH_4650", "4650", ELF::EF_MIPS_MACH_4650 }, | |||
1469 | ENUM_ENT(EF_MIPS_MACH_4120, "4120"){ "EF_MIPS_MACH_4120", "4120", ELF::EF_MIPS_MACH_4120 }, | |||
1470 | ENUM_ENT(EF_MIPS_MACH_4111, "4111"){ "EF_MIPS_MACH_4111", "4111", ELF::EF_MIPS_MACH_4111 }, | |||
1471 | ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"){ "EF_MIPS_MACH_SB1", "sb1", ELF::EF_MIPS_MACH_SB1 }, | |||
1472 | ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"){ "EF_MIPS_MACH_OCTEON", "octeon", ELF::EF_MIPS_MACH_OCTEON }, | |||
1473 | ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"){ "EF_MIPS_MACH_XLR", "xlr", ELF::EF_MIPS_MACH_XLR }, | |||
1474 | ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"){ "EF_MIPS_MACH_OCTEON2", "octeon2", ELF::EF_MIPS_MACH_OCTEON2 }, | |||
1475 | ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"){ "EF_MIPS_MACH_OCTEON3", "octeon3", ELF::EF_MIPS_MACH_OCTEON3 }, | |||
1476 | ENUM_ENT(EF_MIPS_MACH_5400, "5400"){ "EF_MIPS_MACH_5400", "5400", ELF::EF_MIPS_MACH_5400 }, | |||
1477 | ENUM_ENT(EF_MIPS_MACH_5900, "5900"){ "EF_MIPS_MACH_5900", "5900", ELF::EF_MIPS_MACH_5900 }, | |||
1478 | ENUM_ENT(EF_MIPS_MACH_5500, "5500"){ "EF_MIPS_MACH_5500", "5500", ELF::EF_MIPS_MACH_5500 }, | |||
1479 | ENUM_ENT(EF_MIPS_MACH_9000, "9000"){ "EF_MIPS_MACH_9000", "9000", ELF::EF_MIPS_MACH_9000 }, | |||
1480 | ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"){ "EF_MIPS_MACH_LS2E", "loongson-2e", ELF::EF_MIPS_MACH_LS2E }, | |||
1481 | ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"){ "EF_MIPS_MACH_LS2F", "loongson-2f", ELF::EF_MIPS_MACH_LS2F }, | |||
1482 | ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"){ "EF_MIPS_MACH_LS3A", "loongson-3a", ELF::EF_MIPS_MACH_LS3A }, | |||
1483 | ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"){ "EF_MIPS_MICROMIPS", "micromips", ELF::EF_MIPS_MICROMIPS }, | |||
1484 | ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"){ "EF_MIPS_ARCH_ASE_M16", "mips16", ELF::EF_MIPS_ARCH_ASE_M16 }, | |||
1485 | ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"){ "EF_MIPS_ARCH_ASE_MDMX", "mdmx", ELF::EF_MIPS_ARCH_ASE_MDMX }, | |||
1486 | ENUM_ENT(EF_MIPS_ARCH_1, "mips1"){ "EF_MIPS_ARCH_1", "mips1", ELF::EF_MIPS_ARCH_1 }, | |||
1487 | ENUM_ENT(EF_MIPS_ARCH_2, "mips2"){ "EF_MIPS_ARCH_2", "mips2", ELF::EF_MIPS_ARCH_2 }, | |||
1488 | ENUM_ENT(EF_MIPS_ARCH_3, "mips3"){ "EF_MIPS_ARCH_3", "mips3", ELF::EF_MIPS_ARCH_3 }, | |||
1489 | ENUM_ENT(EF_MIPS_ARCH_4, "mips4"){ "EF_MIPS_ARCH_4", "mips4", ELF::EF_MIPS_ARCH_4 }, | |||
1490 | ENUM_ENT(EF_MIPS_ARCH_5, "mips5"){ "EF_MIPS_ARCH_5", "mips5", ELF::EF_MIPS_ARCH_5 }, | |||
1491 | ENUM_ENT(EF_MIPS_ARCH_32, "mips32"){ "EF_MIPS_ARCH_32", "mips32", ELF::EF_MIPS_ARCH_32 }, | |||
1492 | ENUM_ENT(EF_MIPS_ARCH_64, "mips64"){ "EF_MIPS_ARCH_64", "mips64", ELF::EF_MIPS_ARCH_64 }, | |||
1493 | ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"){ "EF_MIPS_ARCH_32R2", "mips32r2", ELF::EF_MIPS_ARCH_32R2 }, | |||
1494 | ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"){ "EF_MIPS_ARCH_64R2", "mips64r2", ELF::EF_MIPS_ARCH_64R2 }, | |||
1495 | ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"){ "EF_MIPS_ARCH_32R6", "mips32r6", ELF::EF_MIPS_ARCH_32R6 }, | |||
1496 | ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6"){ "EF_MIPS_ARCH_64R6", "mips64r6", ELF::EF_MIPS_ARCH_64R6 } | |||
1497 | }; | |||
1498 | ||||
1499 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion3[] = { | |||
1500 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1501 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1502 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1503 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1504 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1505 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1506 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1507 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1508 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1509 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1510 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1511 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1512 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1513 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1514 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1515 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1516 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1517 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1518 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1519 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1520 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1521 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1522 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1523 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1524 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1525 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1526 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1527 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1528 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1529 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1530 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1531 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1532 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1533 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1534 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1535 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1536 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1537 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1538 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1539 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1540 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1541 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1542 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1543 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1544 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1545 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1546 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1547 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1548 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1549 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1550 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1551 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1100){ "EF_AMDGPU_MACH_AMDGCN_GFX1100", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100 }, | |||
1552 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1101){ "EF_AMDGPU_MACH_AMDGCN_GFX1101", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101 }, | |||
1553 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1102){ "EF_AMDGPU_MACH_AMDGCN_GFX1102", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102 }, | |||
1554 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1103){ "EF_AMDGPU_MACH_AMDGCN_GFX1103", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103 }, | |||
1555 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_V3){ "EF_AMDGPU_FEATURE_XNACK_V3", ELF::EF_AMDGPU_FEATURE_XNACK_V3 }, | |||
1556 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_V3){ "EF_AMDGPU_FEATURE_SRAMECC_V3", ELF::EF_AMDGPU_FEATURE_SRAMECC_V3 } | |||
1557 | }; | |||
1558 | ||||
1559 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion4[] = { | |||
1560 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1561 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1562 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1563 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1564 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1565 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1566 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1567 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1568 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1569 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1570 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1571 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1572 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1573 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1574 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1575 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1576 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1577 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1578 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1579 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1580 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1581 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1582 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1583 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1584 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1585 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1586 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1587 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1588 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1589 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1590 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1591 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1592 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1593 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1594 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1595 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1596 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1597 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1598 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1599 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1600 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1601 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1602 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1603 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1604 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1605 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1606 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1607 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1608 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1609 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1610 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1611 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1100){ "EF_AMDGPU_MACH_AMDGCN_GFX1100", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100 }, | |||
1612 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1101){ "EF_AMDGPU_MACH_AMDGCN_GFX1101", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101 }, | |||
1613 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1102){ "EF_AMDGPU_MACH_AMDGCN_GFX1102", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102 }, | |||
1614 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1103){ "EF_AMDGPU_MACH_AMDGCN_GFX1103", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103 }, | |||
1615 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ANY_V4){ "EF_AMDGPU_FEATURE_XNACK_ANY_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4 }, | |||
1616 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_OFF_V4){ "EF_AMDGPU_FEATURE_XNACK_OFF_V4", ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4 }, | |||
1617 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ON_V4){ "EF_AMDGPU_FEATURE_XNACK_ON_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4 }, | |||
1618 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ANY_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ANY_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4 }, | |||
1619 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_OFF_V4){ "EF_AMDGPU_FEATURE_SRAMECC_OFF_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4 }, | |||
1620 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ON_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ON_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4 } | |||
1621 | }; | |||
1622 | ||||
1623 | const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = { | |||
1624 | ENUM_ENT(EF_RISCV_RVC, "RVC"){ "EF_RISCV_RVC", "RVC", ELF::EF_RISCV_RVC }, | |||
1625 | ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"){ "EF_RISCV_FLOAT_ABI_SINGLE", "single-float ABI", ELF::EF_RISCV_FLOAT_ABI_SINGLE }, | |||
1626 | ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"){ "EF_RISCV_FLOAT_ABI_DOUBLE", "double-float ABI", ELF::EF_RISCV_FLOAT_ABI_DOUBLE }, | |||
1627 | ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"){ "EF_RISCV_FLOAT_ABI_QUAD", "quad-float ABI", ELF::EF_RISCV_FLOAT_ABI_QUAD }, | |||
1628 | ENUM_ENT(EF_RISCV_RVE, "RVE"){ "EF_RISCV_RVE", "RVE", ELF::EF_RISCV_RVE }, | |||
1629 | ENUM_ENT(EF_RISCV_TSO, "TSO"){ "EF_RISCV_TSO", "TSO", ELF::EF_RISCV_TSO }, | |||
1630 | }; | |||
1631 | ||||
1632 | const EnumEntry<unsigned> ElfHeaderAVRFlags[] = { | |||
1633 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR1){ "EF_AVR_ARCH_AVR1", ELF::EF_AVR_ARCH_AVR1 }, | |||
1634 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR2){ "EF_AVR_ARCH_AVR2", ELF::EF_AVR_ARCH_AVR2 }, | |||
1635 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR25){ "EF_AVR_ARCH_AVR25", ELF::EF_AVR_ARCH_AVR25 }, | |||
1636 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR3){ "EF_AVR_ARCH_AVR3", ELF::EF_AVR_ARCH_AVR3 }, | |||
1637 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR31){ "EF_AVR_ARCH_AVR31", ELF::EF_AVR_ARCH_AVR31 }, | |||
1638 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR35){ "EF_AVR_ARCH_AVR35", ELF::EF_AVR_ARCH_AVR35 }, | |||
1639 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR4){ "EF_AVR_ARCH_AVR4", ELF::EF_AVR_ARCH_AVR4 }, | |||
1640 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR5){ "EF_AVR_ARCH_AVR5", ELF::EF_AVR_ARCH_AVR5 }, | |||
1641 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR51){ "EF_AVR_ARCH_AVR51", ELF::EF_AVR_ARCH_AVR51 }, | |||
1642 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR6){ "EF_AVR_ARCH_AVR6", ELF::EF_AVR_ARCH_AVR6 }, | |||
1643 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVRTINY){ "EF_AVR_ARCH_AVRTINY", ELF::EF_AVR_ARCH_AVRTINY }, | |||
1644 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA1){ "EF_AVR_ARCH_XMEGA1", ELF::EF_AVR_ARCH_XMEGA1 }, | |||
1645 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA2){ "EF_AVR_ARCH_XMEGA2", ELF::EF_AVR_ARCH_XMEGA2 }, | |||
1646 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3){ "EF_AVR_ARCH_XMEGA3", ELF::EF_AVR_ARCH_XMEGA3 }, | |||
1647 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4){ "EF_AVR_ARCH_XMEGA4", ELF::EF_AVR_ARCH_XMEGA4 }, | |||
1648 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5){ "EF_AVR_ARCH_XMEGA5", ELF::EF_AVR_ARCH_XMEGA5 }, | |||
1649 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6){ "EF_AVR_ARCH_XMEGA6", ELF::EF_AVR_ARCH_XMEGA6 }, | |||
1650 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7){ "EF_AVR_ARCH_XMEGA7", ELF::EF_AVR_ARCH_XMEGA7 }, | |||
1651 | ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"){ "EF_AVR_LINKRELAX_PREPARED", "relaxable", ELF::EF_AVR_LINKRELAX_PREPARED }, | |||
1652 | }; | |||
1653 | ||||
1654 | const EnumEntry<unsigned> ElfHeaderLoongArchFlags[] = { | |||
1655 | ENUM_ENT(EF_LOONGARCH_ABI_SOFT_FLOAT, "SOFT-FLOAT"){ "EF_LOONGARCH_ABI_SOFT_FLOAT", "SOFT-FLOAT", ELF::EF_LOONGARCH_ABI_SOFT_FLOAT }, | |||
1656 | ENUM_ENT(EF_LOONGARCH_ABI_SINGLE_FLOAT, "SINGLE-FLOAT"){ "EF_LOONGARCH_ABI_SINGLE_FLOAT", "SINGLE-FLOAT", ELF::EF_LOONGARCH_ABI_SINGLE_FLOAT }, | |||
1657 | ENUM_ENT(EF_LOONGARCH_ABI_DOUBLE_FLOAT, "DOUBLE-FLOAT"){ "EF_LOONGARCH_ABI_DOUBLE_FLOAT", "DOUBLE-FLOAT", ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT }, | |||
1658 | ENUM_ENT(EF_LOONGARCH_OBJABI_V0, "OBJ-v0"){ "EF_LOONGARCH_OBJABI_V0", "OBJ-v0", ELF::EF_LOONGARCH_OBJABI_V0 }, | |||
1659 | ENUM_ENT(EF_LOONGARCH_OBJABI_V1, "OBJ-v1"){ "EF_LOONGARCH_OBJABI_V1", "OBJ-v1", ELF::EF_LOONGARCH_OBJABI_V1 }, | |||
1660 | }; | |||
1661 | ||||
1662 | ||||
1663 | const EnumEntry<unsigned> ElfSymOtherFlags[] = { | |||
1664 | LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL){ "STV_INTERNAL", ELF::STV_INTERNAL }, | |||
1665 | LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN){ "STV_HIDDEN", ELF::STV_HIDDEN }, | |||
1666 | LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED){ "STV_PROTECTED", ELF::STV_PROTECTED } | |||
1667 | }; | |||
1668 | ||||
1669 | const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = { | |||
1670 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1671 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1672 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC){ "STO_MIPS_PIC", ELF::STO_MIPS_PIC }, | |||
1673 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS){ "STO_MIPS_MICROMIPS", ELF::STO_MIPS_MICROMIPS } | |||
1674 | }; | |||
1675 | ||||
1676 | const EnumEntry<unsigned> ElfAArch64SymOtherFlags[] = { | |||
1677 | LLVM_READOBJ_ENUM_ENT(ELF, STO_AARCH64_VARIANT_PCS){ "STO_AARCH64_VARIANT_PCS", ELF::STO_AARCH64_VARIANT_PCS } | |||
1678 | }; | |||
1679 | ||||
1680 | const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = { | |||
1681 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1682 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1683 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16){ "STO_MIPS_MIPS16", ELF::STO_MIPS_MIPS16 } | |||
1684 | }; | |||
1685 | ||||
1686 | const EnumEntry<unsigned> ElfRISCVSymOtherFlags[] = { | |||
1687 | LLVM_READOBJ_ENUM_ENT(ELF, STO_RISCV_VARIANT_CC){ "STO_RISCV_VARIANT_CC", ELF::STO_RISCV_VARIANT_CC }}; | |||
1688 | ||||
1689 | static const char *getElfMipsOptionsOdkType(unsigned Odk) { | |||
1690 | switch (Odk) { | |||
1691 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL)case ELF::ODK_NULL: return "ODK_NULL";; | |||
1692 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO)case ELF::ODK_REGINFO: return "ODK_REGINFO";; | |||
1693 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS)case ELF::ODK_EXCEPTIONS: return "ODK_EXCEPTIONS";; | |||
1694 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD)case ELF::ODK_PAD: return "ODK_PAD";; | |||
1695 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH)case ELF::ODK_HWPATCH: return "ODK_HWPATCH";; | |||
1696 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL)case ELF::ODK_FILL: return "ODK_FILL";; | |||
1697 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS)case ELF::ODK_TAGS: return "ODK_TAGS";; | |||
1698 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND)case ELF::ODK_HWAND: return "ODK_HWAND";; | |||
1699 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR)case ELF::ODK_HWOR: return "ODK_HWOR";; | |||
1700 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP)case ELF::ODK_GP_GROUP: return "ODK_GP_GROUP";; | |||
1701 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT)case ELF::ODK_IDENT: return "ODK_IDENT";; | |||
1702 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE)case ELF::ODK_PAGESIZE: return "ODK_PAGESIZE";; | |||
1703 | default: | |||
1704 | return "Unknown"; | |||
1705 | } | |||
1706 | } | |||
1707 | ||||
1708 | template <typename ELFT> | |||
1709 | std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *> | |||
1710 | ELFDumper<ELFT>::findDynamic() { | |||
1711 | // Try to locate the PT_DYNAMIC header. | |||
1712 | const Elf_Phdr *DynamicPhdr = nullptr; | |||
1713 | if (Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj.program_headers()) { | |||
1714 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
1715 | if (Phdr.p_type != ELF::PT_DYNAMIC) | |||
1716 | continue; | |||
1717 | DynamicPhdr = &Phdr; | |||
1718 | break; | |||
1719 | } | |||
1720 | } else { | |||
1721 | reportUniqueWarning( | |||
1722 | "unable to read program headers to locate the PT_DYNAMIC segment: " + | |||
1723 | toString(PhdrsOrErr.takeError())); | |||
1724 | } | |||
1725 | ||||
1726 | // Try to locate the .dynamic section in the sections header table. | |||
1727 | const Elf_Shdr *DynamicSec = nullptr; | |||
1728 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
1729 | if (Sec.sh_type != ELF::SHT_DYNAMIC) | |||
1730 | continue; | |||
1731 | DynamicSec = &Sec; | |||
1732 | break; | |||
1733 | } | |||
1734 | ||||
1735 | if (DynamicPhdr && ((DynamicPhdr->p_offset + DynamicPhdr->p_filesz > | |||
1736 | ObjF.getMemoryBufferRef().getBufferSize()) || | |||
1737 | (DynamicPhdr->p_offset + DynamicPhdr->p_filesz < | |||
1738 | DynamicPhdr->p_offset))) { | |||
1739 | reportUniqueWarning( | |||
1740 | "PT_DYNAMIC segment offset (0x" + | |||
1741 | Twine::utohexstr(DynamicPhdr->p_offset) + ") + file size (0x" + | |||
1742 | Twine::utohexstr(DynamicPhdr->p_filesz) + | |||
1743 | ") exceeds the size of the file (0x" + | |||
1744 | Twine::utohexstr(ObjF.getMemoryBufferRef().getBufferSize()) + ")"); | |||
1745 | // Don't use the broken dynamic header. | |||
1746 | DynamicPhdr = nullptr; | |||
1747 | } | |||
1748 | ||||
1749 | if (DynamicPhdr && DynamicSec) { | |||
1750 | if (DynamicSec->sh_addr + DynamicSec->sh_size > | |||
1751 | DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz || | |||
1752 | DynamicSec->sh_addr < DynamicPhdr->p_vaddr) | |||
1753 | reportUniqueWarning(describe(*DynamicSec) + | |||
1754 | " is not contained within the " | |||
1755 | "PT_DYNAMIC segment"); | |||
1756 | ||||
1757 | if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr) | |||
1758 | reportUniqueWarning(describe(*DynamicSec) + " is not at the start of " | |||
1759 | "PT_DYNAMIC segment"); | |||
1760 | } | |||
1761 | ||||
1762 | return std::make_pair(DynamicPhdr, DynamicSec); | |||
1763 | } | |||
1764 | ||||
1765 | template <typename ELFT> | |||
1766 | void ELFDumper<ELFT>::loadDynamicTable() { | |||
1767 | const Elf_Phdr *DynamicPhdr; | |||
1768 | const Elf_Shdr *DynamicSec; | |||
1769 | std::tie(DynamicPhdr, DynamicSec) = findDynamic(); | |||
1770 | if (!DynamicPhdr && !DynamicSec) | |||
1771 | return; | |||
1772 | ||||
1773 | DynRegionInfo FromPhdr(ObjF, *this); | |||
1774 | bool IsPhdrTableValid = false; | |||
1775 | if (DynamicPhdr) { | |||
1776 | // Use cantFail(), because p_offset/p_filesz fields of a PT_DYNAMIC are | |||
1777 | // validated in findDynamic() and so createDRI() is not expected to fail. | |||
1778 | FromPhdr = cantFail(createDRI(DynamicPhdr->p_offset, DynamicPhdr->p_filesz, | |||
1779 | sizeof(Elf_Dyn))); | |||
1780 | FromPhdr.SizePrintName = "PT_DYNAMIC size"; | |||
1781 | FromPhdr.EntSizePrintName = ""; | |||
1782 | IsPhdrTableValid = !FromPhdr.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1783 | } | |||
1784 | ||||
1785 | // Locate the dynamic table described in a section header. | |||
1786 | // Ignore sh_entsize and use the expected value for entry size explicitly. | |||
1787 | // This allows us to dump dynamic sections with a broken sh_entsize | |||
1788 | // field. | |||
1789 | DynRegionInfo FromSec(ObjF, *this); | |||
1790 | bool IsSecTableValid = false; | |||
1791 | if (DynamicSec) { | |||
1792 | Expected<DynRegionInfo> RegOrErr = | |||
1793 | createDRI(DynamicSec->sh_offset, DynamicSec->sh_size, sizeof(Elf_Dyn)); | |||
1794 | if (RegOrErr) { | |||
1795 | FromSec = *RegOrErr; | |||
1796 | FromSec.Context = describe(*DynamicSec); | |||
1797 | FromSec.EntSizePrintName = ""; | |||
1798 | IsSecTableValid = !FromSec.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1799 | } else { | |||
1800 | reportUniqueWarning("unable to read the dynamic table from " + | |||
1801 | describe(*DynamicSec) + ": " + | |||
1802 | toString(RegOrErr.takeError())); | |||
1803 | } | |||
1804 | } | |||
1805 | ||||
1806 | // When we only have information from one of the SHT_DYNAMIC section header or | |||
1807 | // PT_DYNAMIC program header, just use that. | |||
1808 | if (!DynamicPhdr || !DynamicSec) { | |||
1809 | if ((DynamicPhdr && IsPhdrTableValid) || (DynamicSec && IsSecTableValid)) { | |||
1810 | DynamicTable = DynamicPhdr ? FromPhdr : FromSec; | |||
1811 | parseDynamicTable(); | |||
1812 | } else { | |||
1813 | reportUniqueWarning("no valid dynamic table was found"); | |||
1814 | } | |||
1815 | return; | |||
1816 | } | |||
1817 | ||||
1818 | // At this point we have tables found from the section header and from the | |||
1819 | // dynamic segment. Usually they match, but we have to do sanity checks to | |||
1820 | // verify that. | |||
1821 | ||||
1822 | if (FromPhdr.Addr != FromSec.Addr) | |||
1823 | reportUniqueWarning("SHT_DYNAMIC section header and PT_DYNAMIC " | |||
1824 | "program header disagree about " | |||
1825 | "the location of the dynamic table"); | |||
1826 | ||||
1827 | if (!IsPhdrTableValid && !IsSecTableValid) { | |||
1828 | reportUniqueWarning("no valid dynamic table was found"); | |||
1829 | return; | |||
1830 | } | |||
1831 | ||||
1832 | // Information in the PT_DYNAMIC program header has priority over the | |||
1833 | // information in a section header. | |||
1834 | if (IsPhdrTableValid) { | |||
1835 | if (!IsSecTableValid) | |||
1836 | reportUniqueWarning( | |||
1837 | "SHT_DYNAMIC dynamic table is invalid: PT_DYNAMIC will be used"); | |||
1838 | DynamicTable = FromPhdr; | |||
1839 | } else { | |||
1840 | reportUniqueWarning( | |||
1841 | "PT_DYNAMIC dynamic table is invalid: SHT_DYNAMIC will be used"); | |||
1842 | DynamicTable = FromSec; | |||
1843 | } | |||
1844 | ||||
1845 | parseDynamicTable(); | |||
1846 | } | |||
1847 | ||||
1848 | template <typename ELFT> | |||
1849 | ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> &O, | |||
1850 | ScopedPrinter &Writer) | |||
1851 | : ObjDumper(Writer, O.getFileName()), ObjF(O), Obj(O.getELFFile()), | |||
1852 | FileName(O.getFileName()), DynRelRegion(O, *this), | |||
1853 | DynRelaRegion(O, *this), DynRelrRegion(O, *this), | |||
1854 | DynPLTRelRegion(O, *this), DynSymTabShndxRegion(O, *this), | |||
1855 | DynamicTable(O, *this) { | |||
1856 | if (!O.IsContentValid()) | |||
1857 | return; | |||
1858 | ||||
1859 | typename ELFT::ShdrRange Sections = cantFail(Obj.sections()); | |||
1860 | for (const Elf_Shdr &Sec : Sections) { | |||
1861 | switch (Sec.sh_type) { | |||
1862 | case ELF::SHT_SYMTAB: | |||
1863 | if (!DotSymtabSec) | |||
1864 | DotSymtabSec = &Sec; | |||
1865 | break; | |||
1866 | case ELF::SHT_DYNSYM: | |||
1867 | if (!DotDynsymSec) | |||
1868 | DotDynsymSec = &Sec; | |||
1869 | ||||
1870 | if (!DynSymRegion) { | |||
1871 | Expected<DynRegionInfo> RegOrErr = | |||
1872 | createDRI(Sec.sh_offset, Sec.sh_size, Sec.sh_entsize); | |||
1873 | if (RegOrErr) { | |||
1874 | DynSymRegion = *RegOrErr; | |||
1875 | DynSymRegion->Context = describe(Sec); | |||
1876 | ||||
1877 | if (Expected<StringRef> E = Obj.getStringTableForSymtab(Sec)) | |||
1878 | DynamicStringTable = *E; | |||
1879 | else | |||
1880 | reportUniqueWarning("unable to get the string table for the " + | |||
1881 | describe(Sec) + ": " + toString(E.takeError())); | |||
1882 | } else { | |||
1883 | reportUniqueWarning("unable to read dynamic symbols from " + | |||
1884 | describe(Sec) + ": " + | |||
1885 | toString(RegOrErr.takeError())); | |||
1886 | } | |||
1887 | } | |||
1888 | break; | |||
1889 | case ELF::SHT_SYMTAB_SHNDX: { | |||
1890 | uint32_t SymtabNdx = Sec.sh_link; | |||
1891 | if (SymtabNdx >= Sections.size()) { | |||
1892 | reportUniqueWarning( | |||
1893 | "unable to get the associated symbol table for " + describe(Sec) + | |||
1894 | ": sh_link (" + Twine(SymtabNdx) + | |||
1895 | ") is greater than or equal to the total number of sections (" + | |||
1896 | Twine(Sections.size()) + ")"); | |||
1897 | continue; | |||
1898 | } | |||
1899 | ||||
1900 | if (Expected<ArrayRef<Elf_Word>> ShndxTableOrErr = | |||
1901 | Obj.getSHNDXTable(Sec)) { | |||
1902 | if (!ShndxTables.insert({&Sections[SymtabNdx], *ShndxTableOrErr}) | |||
1903 | .second) | |||
1904 | reportUniqueWarning( | |||
1905 | "multiple SHT_SYMTAB_SHNDX sections are linked to " + | |||
1906 | describe(Sec)); | |||
1907 | } else { | |||
1908 | reportUniqueWarning(ShndxTableOrErr.takeError()); | |||
1909 | } | |||
1910 | break; | |||
1911 | } | |||
1912 | case ELF::SHT_GNU_versym: | |||
1913 | if (!SymbolVersionSection) | |||
1914 | SymbolVersionSection = &Sec; | |||
1915 | break; | |||
1916 | case ELF::SHT_GNU_verdef: | |||
1917 | if (!SymbolVersionDefSection) | |||
1918 | SymbolVersionDefSection = &Sec; | |||
1919 | break; | |||
1920 | case ELF::SHT_GNU_verneed: | |||
1921 | if (!SymbolVersionNeedSection) | |||
1922 | SymbolVersionNeedSection = &Sec; | |||
1923 | break; | |||
1924 | case ELF::SHT_LLVM_ADDRSIG: | |||
1925 | if (!DotAddrsigSec) | |||
1926 | DotAddrsigSec = &Sec; | |||
1927 | break; | |||
1928 | } | |||
1929 | } | |||
1930 | ||||
1931 | loadDynamicTable(); | |||
1932 | } | |||
1933 | ||||
1934 | template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() { | |||
1935 | auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * { | |||
1936 | auto MappedAddrOrError = Obj.toMappedAddr(VAddr, [&](const Twine &Msg) { | |||
1937 | this->reportUniqueWarning(Msg); | |||
1938 | return Error::success(); | |||
1939 | }); | |||
1940 | if (!MappedAddrOrError) { | |||
1941 | this->reportUniqueWarning("unable to parse DT_" + | |||
1942 | Obj.getDynamicTagAsString(Tag) + ": " + | |||
1943 | llvm::toString(MappedAddrOrError.takeError())); | |||
1944 | return nullptr; | |||
1945 | } | |||
1946 | return MappedAddrOrError.get(); | |||
1947 | }; | |||
1948 | ||||
1949 | const char *StringTableBegin = nullptr; | |||
1950 | uint64_t StringTableSize = 0; | |||
1951 | Optional<DynRegionInfo> DynSymFromTable; | |||
1952 | for (const Elf_Dyn &Dyn : dynamic_table()) { | |||
1953 | switch (Dyn.d_tag) { | |||
1954 | case ELF::DT_HASH: | |||
1955 | HashTable = reinterpret_cast<const Elf_Hash *>( | |||
1956 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1957 | break; | |||
1958 | case ELF::DT_GNU_HASH: | |||
1959 | GnuHashTable = reinterpret_cast<const Elf_GnuHash *>( | |||
1960 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1961 | break; | |||
1962 | case ELF::DT_STRTAB: | |||
1963 | StringTableBegin = reinterpret_cast<const char *>( | |||
1964 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
1965 | break; | |||
1966 | case ELF::DT_STRSZ: | |||
1967 | StringTableSize = Dyn.getVal(); | |||
1968 | break; | |||
1969 | case ELF::DT_SYMTAB: { | |||
1970 | // If we can't map the DT_SYMTAB value to an address (e.g. when there are | |||
1971 | // no program headers), we ignore its value. | |||
1972 | if (const uint8_t *VA = toMappedAddr(Dyn.getTag(), Dyn.getPtr())) { | |||
1973 | DynSymFromTable.emplace(ObjF, *this); | |||
1974 | DynSymFromTable->Addr = VA; | |||
1975 | DynSymFromTable->EntSize = sizeof(Elf_Sym); | |||
1976 | DynSymFromTable->EntSizePrintName = ""; | |||
1977 | } | |||
1978 | break; | |||
1979 | } | |||
1980 | case ELF::DT_SYMENT: { | |||
1981 | uint64_t Val = Dyn.getVal(); | |||
1982 | if (Val != sizeof(Elf_Sym)) | |||
1983 | this->reportUniqueWarning("DT_SYMENT value of 0x" + | |||
1984 | Twine::utohexstr(Val) + | |||
1985 | " is not the size of a symbol (0x" + | |||
1986 | Twine::utohexstr(sizeof(Elf_Sym)) + ")"); | |||
1987 | break; | |||
1988 | } | |||
1989 | case ELF::DT_RELA: | |||
1990 | DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
1991 | break; | |||
1992 | case ELF::DT_RELASZ: | |||
1993 | DynRelaRegion.Size = Dyn.getVal(); | |||
1994 | DynRelaRegion.SizePrintName = "DT_RELASZ value"; | |||
1995 | break; | |||
1996 | case ELF::DT_RELAENT: | |||
1997 | DynRelaRegion.EntSize = Dyn.getVal(); | |||
1998 | DynRelaRegion.EntSizePrintName = "DT_RELAENT value"; | |||
1999 | break; | |||
2000 | case ELF::DT_SONAME: | |||
2001 | SONameOffset = Dyn.getVal(); | |||
2002 | break; | |||
2003 | case ELF::DT_REL: | |||
2004 | DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2005 | break; | |||
2006 | case ELF::DT_RELSZ: | |||
2007 | DynRelRegion.Size = Dyn.getVal(); | |||
2008 | DynRelRegion.SizePrintName = "DT_RELSZ value"; | |||
2009 | break; | |||
2010 | case ELF::DT_RELENT: | |||
2011 | DynRelRegion.EntSize = Dyn.getVal(); | |||
2012 | DynRelRegion.EntSizePrintName = "DT_RELENT value"; | |||
2013 | break; | |||
2014 | case ELF::DT_RELR: | |||
2015 | case ELF::DT_ANDROID_RELR: | |||
2016 | DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2017 | break; | |||
2018 | case ELF::DT_RELRSZ: | |||
2019 | case ELF::DT_ANDROID_RELRSZ: | |||
2020 | DynRelrRegion.Size = Dyn.getVal(); | |||
2021 | DynRelrRegion.SizePrintName = Dyn.d_tag == ELF::DT_RELRSZ | |||
2022 | ? "DT_RELRSZ value" | |||
2023 | : "DT_ANDROID_RELRSZ value"; | |||
2024 | break; | |||
2025 | case ELF::DT_RELRENT: | |||
2026 | case ELF::DT_ANDROID_RELRENT: | |||
2027 | DynRelrRegion.EntSize = Dyn.getVal(); | |||
2028 | DynRelrRegion.EntSizePrintName = Dyn.d_tag == ELF::DT_RELRENT | |||
2029 | ? "DT_RELRENT value" | |||
2030 | : "DT_ANDROID_RELRENT value"; | |||
2031 | break; | |||
2032 | case ELF::DT_PLTREL: | |||
2033 | if (Dyn.getVal() == DT_REL) | |||
2034 | DynPLTRelRegion.EntSize = sizeof(Elf_Rel); | |||
2035 | else if (Dyn.getVal() == DT_RELA) | |||
2036 | DynPLTRelRegion.EntSize = sizeof(Elf_Rela); | |||
2037 | else | |||
2038 | reportUniqueWarning(Twine("unknown DT_PLTREL value of ") + | |||
2039 | Twine((uint64_t)Dyn.getVal())); | |||
2040 | DynPLTRelRegion.EntSizePrintName = "PLTREL entry size"; | |||
2041 | break; | |||
2042 | case ELF::DT_JMPREL: | |||
2043 | DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2044 | break; | |||
2045 | case ELF::DT_PLTRELSZ: | |||
2046 | DynPLTRelRegion.Size = Dyn.getVal(); | |||
2047 | DynPLTRelRegion.SizePrintName = "DT_PLTRELSZ value"; | |||
2048 | break; | |||
2049 | case ELF::DT_SYMTAB_SHNDX: | |||
2050 | DynSymTabShndxRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2051 | DynSymTabShndxRegion.EntSize = sizeof(Elf_Word); | |||
2052 | break; | |||
2053 | } | |||
2054 | } | |||
2055 | ||||
2056 | if (StringTableBegin) { | |||
2057 | const uint64_t FileSize = Obj.getBufSize(); | |||
2058 | const uint64_t Offset = (const uint8_t *)StringTableBegin - Obj.base(); | |||
2059 | if (StringTableSize > FileSize - Offset) | |||
2060 | reportUniqueWarning( | |||
2061 | "the dynamic string table at 0x" + Twine::utohexstr(Offset) + | |||
2062 | " goes past the end of the file (0x" + Twine::utohexstr(FileSize) + | |||
2063 | ") with DT_STRSZ = 0x" + Twine::utohexstr(StringTableSize)); | |||
2064 | else | |||
2065 | DynamicStringTable = StringRef(StringTableBegin, StringTableSize); | |||
2066 | } | |||
2067 | ||||
2068 | const bool IsHashTableSupported = getHashTableEntSize() == 4; | |||
2069 | if (DynSymRegion) { | |||
2070 | // Often we find the information about the dynamic symbol table | |||
2071 | // location in the SHT_DYNSYM section header. However, the value in | |||
2072 | // DT_SYMTAB has priority, because it is used by dynamic loaders to | |||
2073 | // locate .dynsym at runtime. The location we find in the section header | |||
2074 | // and the location we find here should match. | |||
2075 | if (DynSymFromTable && DynSymFromTable->Addr != DynSymRegion->Addr) | |||
2076 | reportUniqueWarning( | |||
2077 | createError("SHT_DYNSYM section header and DT_SYMTAB disagree about " | |||
2078 | "the location of the dynamic symbol table")); | |||
2079 | ||||
2080 | // According to the ELF gABI: "The number of symbol table entries should | |||
2081 | // equal nchain". Check to see if the DT_HASH hash table nchain value | |||
2082 | // conflicts with the number of symbols in the dynamic symbol table | |||
2083 | // according to the section header. | |||
2084 | if (HashTable && IsHashTableSupported) { | |||
2085 | if (DynSymRegion->EntSize == 0) | |||
2086 | reportUniqueWarning("SHT_DYNSYM section has sh_entsize == 0"); | |||
2087 | else if (HashTable->nchain != DynSymRegion->Size / DynSymRegion->EntSize) | |||
2088 | reportUniqueWarning( | |||
2089 | "hash table nchain (" + Twine(HashTable->nchain) + | |||
2090 | ") differs from symbol count derived from SHT_DYNSYM section " | |||
2091 | "header (" + | |||
2092 | Twine(DynSymRegion->Size / DynSymRegion->EntSize) + ")"); | |||
2093 | } | |||
2094 | } | |||
2095 | ||||
2096 | // Delay the creation of the actual dynamic symbol table until now, so that | |||
2097 | // checks can always be made against the section header-based properties, | |||
2098 | // without worrying about tag order. | |||
2099 | if (DynSymFromTable) { | |||
2100 | if (!DynSymRegion) { | |||
2101 | DynSymRegion = DynSymFromTable; | |||
2102 | } else { | |||
2103 | DynSymRegion->Addr = DynSymFromTable->Addr; | |||
2104 | DynSymRegion->EntSize = DynSymFromTable->EntSize; | |||
2105 | DynSymRegion->EntSizePrintName = DynSymFromTable->EntSizePrintName; | |||
2106 | } | |||
2107 | } | |||
2108 | ||||
2109 | // Derive the dynamic symbol table size from the DT_HASH hash table, if | |||
2110 | // present. | |||
2111 | if (HashTable && IsHashTableSupported && DynSymRegion) { | |||
2112 | const uint64_t FileSize = Obj.getBufSize(); | |||
2113 | const uint64_t DerivedSize = | |||
2114 | (uint64_t)HashTable->nchain * DynSymRegion->EntSize; | |||
2115 | const uint64_t Offset = (const uint8_t *)DynSymRegion->Addr - Obj.base(); | |||
2116 | if (DerivedSize > FileSize - Offset) | |||
2117 | reportUniqueWarning( | |||
2118 | "the size (0x" + Twine::utohexstr(DerivedSize) + | |||
2119 | ") of the dynamic symbol table at 0x" + Twine::utohexstr(Offset) + | |||
2120 | ", derived from the hash table, goes past the end of the file (0x" + | |||
2121 | Twine::utohexstr(FileSize) + ") and will be ignored"); | |||
2122 | else | |||
2123 | DynSymRegion->Size = HashTable->nchain * DynSymRegion->EntSize; | |||
2124 | } | |||
2125 | } | |||
2126 | ||||
2127 | template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { | |||
2128 | // Dump version symbol section. | |||
2129 | printVersionSymbolSection(SymbolVersionSection); | |||
2130 | ||||
2131 | // Dump version definition section. | |||
2132 | printVersionDefinitionSection(SymbolVersionDefSection); | |||
2133 | ||||
2134 | // Dump version dependency section. | |||
2135 | printVersionDependencySection(SymbolVersionNeedSection); | |||
2136 | } | |||
2137 | ||||
2138 | #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ | |||
2139 | { #enum, prefix##_##enum } | |||
2140 | ||||
2141 | const EnumEntry<unsigned> ElfDynamicDTFlags[] = { | |||
2142 | LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), | |||
2143 | LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), | |||
2144 | LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), | |||
2145 | LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), | |||
2146 | LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) | |||
2147 | }; | |||
2148 | ||||
2149 | const EnumEntry<unsigned> ElfDynamicDTFlags1[] = { | |||
2150 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), | |||
2151 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), | |||
2152 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), | |||
2153 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), | |||
2154 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), | |||
2155 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), | |||
2156 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), | |||
2157 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), | |||
2158 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), | |||
2159 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), | |||
2160 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), | |||
2161 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), | |||
2162 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), | |||
2163 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), | |||
2164 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), | |||
2165 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), | |||
2166 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND), | |||
2167 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), | |||
2168 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), | |||
2169 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), | |||
2170 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), | |||
2171 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), | |||
2172 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), | |||
2173 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), | |||
2174 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), | |||
2175 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON), | |||
2176 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE), | |||
2177 | }; | |||
2178 | ||||
2179 | const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = { | |||
2180 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), | |||
2181 | LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), | |||
2182 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), | |||
2183 | LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), | |||
2184 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), | |||
2185 | LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), | |||
2186 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), | |||
2187 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), | |||
2188 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), | |||
2189 | LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), | |||
2190 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), | |||
2191 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), | |||
2192 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), | |||
2193 | LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), | |||
2194 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), | |||
2195 | LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) | |||
2196 | }; | |||
2197 | ||||
2198 | #undef LLVM_READOBJ_DT_FLAG_ENT | |||
2199 | ||||
2200 | template <typename T, typename TFlag> | |||
2201 | void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) { | |||
2202 | SmallVector<EnumEntry<TFlag>, 10> SetFlags; | |||
2203 | for (const EnumEntry<TFlag> &Flag : Flags) | |||
2204 | if (Flag.Value != 0 && (Value & Flag.Value) == Flag.Value) | |||
2205 | SetFlags.push_back(Flag); | |||
2206 | ||||
2207 | for (const EnumEntry<TFlag> &Flag : SetFlags) | |||
2208 | OS << Flag.Name << " "; | |||
2209 | } | |||
2210 | ||||
2211 | template <class ELFT> | |||
2212 | const typename ELFT::Shdr * | |||
2213 | ELFDumper<ELFT>::findSectionByName(StringRef Name) const { | |||
2214 | for (const Elf_Shdr &Shdr : cantFail(Obj.sections())) { | |||
2215 | if (Expected<StringRef> NameOrErr = Obj.getSectionName(Shdr)) { | |||
2216 | if (*NameOrErr == Name) | |||
2217 | return &Shdr; | |||
2218 | } else { | |||
2219 | reportUniqueWarning("unable to read the name of " + describe(Shdr) + | |||
2220 | ": " + toString(NameOrErr.takeError())); | |||
2221 | } | |||
2222 | } | |||
2223 | return nullptr; | |||
2224 | } | |||
2225 | ||||
2226 | template <class ELFT> | |||
2227 | std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type, | |||
2228 | uint64_t Value) const { | |||
2229 | auto FormatHexValue = [](uint64_t V) { | |||
2230 | std::string Str; | |||
2231 | raw_string_ostream OS(Str); | |||
2232 | const char *ConvChar = | |||
2233 | (opts::Output == opts::GNU) ? "0x%" PRIx64"l" "x" : "0x%" PRIX64"l" "X"; | |||
2234 | OS << format(ConvChar, V); | |||
2235 | return OS.str(); | |||
2236 | }; | |||
2237 | ||||
2238 | auto FormatFlags = [](uint64_t V, | |||
2239 | llvm::ArrayRef<llvm::EnumEntry<unsigned int>> Array) { | |||
2240 | std::string Str; | |||
2241 | raw_string_ostream OS(Str); | |||
2242 | printFlags(V, Array, OS); | |||
2243 | return OS.str(); | |||
2244 | }; | |||
2245 | ||||
2246 | // Handle custom printing of architecture specific tags | |||
2247 | switch (Obj.getHeader().e_machine) { | |||
2248 | case EM_AARCH64: | |||
2249 | switch (Type) { | |||
2250 | case DT_AARCH64_BTI_PLT: | |||
2251 | case DT_AARCH64_PAC_PLT: | |||
2252 | case DT_AARCH64_VARIANT_PCS: | |||
2253 | return std::to_string(Value); | |||
2254 | default: | |||
2255 | break; | |||
2256 | } | |||
2257 | break; | |||
2258 | case EM_HEXAGON: | |||
2259 | switch (Type) { | |||
2260 | case DT_HEXAGON_VER: | |||
2261 | return std::to_string(Value); | |||
2262 | case DT_HEXAGON_SYMSZ: | |||
2263 | case DT_HEXAGON_PLT: | |||
2264 | return FormatHexValue(Value); | |||
2265 | default: | |||
2266 | break; | |||
2267 | } | |||
2268 | break; | |||
2269 | case EM_MIPS: | |||
2270 | switch (Type) { | |||
2271 | case DT_MIPS_RLD_VERSION: | |||
2272 | case DT_MIPS_LOCAL_GOTNO: | |||
2273 | case DT_MIPS_SYMTABNO: | |||
2274 | case DT_MIPS_UNREFEXTNO: | |||
2275 | return std::to_string(Value); | |||
2276 | case DT_MIPS_TIME_STAMP: | |||
2277 | case DT_MIPS_ICHECKSUM: | |||
2278 | case DT_MIPS_IVERSION: | |||
2279 | case DT_MIPS_BASE_ADDRESS: | |||
2280 | case DT_MIPS_MSYM: | |||
2281 | case DT_MIPS_CONFLICT: | |||
2282 | case DT_MIPS_LIBLIST: | |||
2283 | case DT_MIPS_CONFLICTNO: | |||
2284 | case DT_MIPS_LIBLISTNO: | |||
2285 | case DT_MIPS_GOTSYM: | |||
2286 | case DT_MIPS_HIPAGENO: | |||
2287 | case DT_MIPS_RLD_MAP: | |||
2288 | case DT_MIPS_DELTA_CLASS: | |||
2289 | case DT_MIPS_DELTA_CLASS_NO: | |||
2290 | case DT_MIPS_DELTA_INSTANCE: | |||
2291 | case DT_MIPS_DELTA_RELOC: | |||
2292 | case DT_MIPS_DELTA_RELOC_NO: | |||
2293 | case DT_MIPS_DELTA_SYM: | |||
2294 | case DT_MIPS_DELTA_SYM_NO: | |||
2295 | case DT_MIPS_DELTA_CLASSSYM: | |||
2296 | case DT_MIPS_DELTA_CLASSSYM_NO: | |||
2297 | case DT_MIPS_CXX_FLAGS: | |||
2298 | case DT_MIPS_PIXIE_INIT: | |||
2299 | case DT_MIPS_SYMBOL_LIB: | |||
2300 | case DT_MIPS_LOCALPAGE_GOTIDX: | |||
2301 | case DT_MIPS_LOCAL_GOTIDX: | |||
2302 | case DT_MIPS_HIDDEN_GOTIDX: | |||
2303 | case DT_MIPS_PROTECTED_GOTIDX: | |||
2304 | case DT_MIPS_OPTIONS: | |||
2305 | case DT_MIPS_INTERFACE: | |||
2306 | case DT_MIPS_DYNSTR_ALIGN: | |||
2307 | case DT_MIPS_INTERFACE_SIZE: | |||
2308 | case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: | |||
2309 | case DT_MIPS_PERF_SUFFIX: | |||
2310 | case DT_MIPS_COMPACT_SIZE: | |||
2311 | case DT_MIPS_GP_VALUE: | |||
2312 | case DT_MIPS_AUX_DYNAMIC: | |||
2313 | case DT_MIPS_PLTGOT: | |||
2314 | case DT_MIPS_RWPLT: | |||
2315 | case DT_MIPS_RLD_MAP_REL: | |||
2316 | case DT_MIPS_XHASH: | |||
2317 | return FormatHexValue(Value); | |||
2318 | case DT_MIPS_FLAGS: | |||
2319 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags)); | |||
2320 | default: | |||
2321 | break; | |||
2322 | } | |||
2323 | break; | |||
2324 | default: | |||
2325 | break; | |||
2326 | } | |||
2327 | ||||
2328 | switch (Type) { | |||
2329 | case DT_PLTREL: | |||
2330 | if (Value == DT_REL) | |||
2331 | return "REL"; | |||
2332 | if (Value == DT_RELA) | |||
2333 | return "RELA"; | |||
2334 | [[fallthrough]]; | |||
2335 | case DT_PLTGOT: | |||
2336 | case DT_HASH: | |||
2337 | case DT_STRTAB: | |||
2338 | case DT_SYMTAB: | |||
2339 | case DT_RELA: | |||
2340 | case DT_INIT: | |||
2341 | case DT_FINI: | |||
2342 | case DT_REL: | |||
2343 | case DT_JMPREL: | |||
2344 | case DT_INIT_ARRAY: | |||
2345 | case DT_FINI_ARRAY: | |||
2346 | case DT_PREINIT_ARRAY: | |||
2347 | case DT_DEBUG: | |||
2348 | case DT_VERDEF: | |||
2349 | case DT_VERNEED: | |||
2350 | case DT_VERSYM: | |||
2351 | case DT_GNU_HASH: | |||
2352 | case DT_NULL: | |||
2353 | return FormatHexValue(Value); | |||
2354 | case DT_RELACOUNT: | |||
2355 | case DT_RELCOUNT: | |||
2356 | case DT_VERDEFNUM: | |||
2357 | case DT_VERNEEDNUM: | |||
2358 | return std::to_string(Value); | |||
2359 | case DT_PLTRELSZ: | |||
2360 | case DT_RELASZ: | |||
2361 | case DT_RELAENT: | |||
2362 | case DT_STRSZ: | |||
2363 | case DT_SYMENT: | |||
2364 | case DT_RELSZ: | |||
2365 | case DT_RELENT: | |||
2366 | case DT_INIT_ARRAYSZ: | |||
2367 | case DT_FINI_ARRAYSZ: | |||
2368 | case DT_PREINIT_ARRAYSZ: | |||
2369 | case DT_RELRSZ: | |||
2370 | case DT_RELRENT: | |||
2371 | case DT_ANDROID_RELSZ: | |||
2372 | case DT_ANDROID_RELASZ: | |||
2373 | return std::to_string(Value) + " (bytes)"; | |||
2374 | case DT_NEEDED: | |||
2375 | case DT_SONAME: | |||
2376 | case DT_AUXILIARY: | |||
2377 | case DT_USED: | |||
2378 | case DT_FILTER: | |||
2379 | case DT_RPATH: | |||
2380 | case DT_RUNPATH: { | |||
2381 | const std::map<uint64_t, const char *> TagNames = { | |||
2382 | {DT_NEEDED, "Shared library"}, {DT_SONAME, "Library soname"}, | |||
2383 | {DT_AUXILIARY, "Auxiliary library"}, {DT_USED, "Not needed object"}, | |||
2384 | {DT_FILTER, "Filter library"}, {DT_RPATH, "Library rpath"}, | |||
2385 | {DT_RUNPATH, "Library runpath"}, | |||
2386 | }; | |||
2387 | ||||
2388 | return (Twine(TagNames.at(Type)) + ": [" + getDynamicString(Value) + "]") | |||
2389 | .str(); | |||
2390 | } | |||
2391 | case DT_FLAGS: | |||
2392 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags)); | |||
2393 | case DT_FLAGS_1: | |||
2394 | return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags1)); | |||
2395 | default: | |||
2396 | return FormatHexValue(Value); | |||
2397 | } | |||
2398 | } | |||
2399 | ||||
2400 | template <class ELFT> | |||
2401 | StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { | |||
2402 | if (DynamicStringTable.empty() && !DynamicStringTable.data()) { | |||
2403 | reportUniqueWarning("string table was not found"); | |||
2404 | return "<?>"; | |||
2405 | } | |||
2406 | ||||
2407 | auto WarnAndReturn = [this](const Twine &Msg, uint64_t Offset) { | |||
2408 | reportUniqueWarning("string table at offset 0x" + Twine::utohexstr(Offset) + | |||
2409 | Msg); | |||
2410 | return "<?>"; | |||
2411 | }; | |||
2412 | ||||
2413 | const uint64_t FileSize = Obj.getBufSize(); | |||
2414 | const uint64_t Offset = | |||
2415 | (const uint8_t *)DynamicStringTable.data() - Obj.base(); | |||
2416 | if (DynamicStringTable.size() > FileSize - Offset) | |||
2417 | return WarnAndReturn(" with size 0x" + | |||
2418 | Twine::utohexstr(DynamicStringTable.size()) + | |||
2419 | " goes past the end of the file (0x" + | |||
2420 | Twine::utohexstr(FileSize) + ")", | |||
2421 | Offset); | |||
2422 | ||||
2423 | if (Value >= DynamicStringTable.size()) | |||
2424 | return WarnAndReturn( | |||
2425 | ": unable to read the string at 0x" + Twine::utohexstr(Offset + Value) + | |||
2426 | ": it goes past the end of the table (0x" + | |||
2427 | Twine::utohexstr(Offset + DynamicStringTable.size()) + ")", | |||
2428 | Offset); | |||
2429 | ||||
2430 | if (DynamicStringTable.back() != '\0') | |||
2431 | return WarnAndReturn(": unable to read the string at 0x" + | |||
2432 | Twine::utohexstr(Offset + Value) + | |||
2433 | ": the string table is not null-terminated", | |||
2434 | Offset); | |||
2435 | ||||
2436 | return DynamicStringTable.data() + Value; | |||
2437 | } | |||
2438 | ||||
2439 | template <class ELFT> void ELFDumper<ELFT>::printUnwindInfo() { | |||
2440 | DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF); | |||
2441 | Ctx.printUnwindInformation(); | |||
2442 | } | |||
2443 | ||||
2444 | // The namespace is needed to fix the compilation with GCC older than 7.0+. | |||
2445 | namespace { | |||
2446 | template <> void ELFDumper<ELF32LE>::printUnwindInfo() { | |||
2447 | if (Obj.getHeader().e_machine == EM_ARM) { | |||
2448 | ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF.getFileName(), | |||
2449 | DotSymtabSec); | |||
2450 | Ctx.PrintUnwindInformation(); | |||
2451 | } | |||
2452 | DwarfCFIEH::PrinterContext<ELF32LE> Ctx(W, ObjF); | |||
2453 | Ctx.printUnwindInformation(); | |||
2454 | } | |||
2455 | } // namespace | |||
2456 | ||||
2457 | template <class ELFT> void ELFDumper<ELFT>::printNeededLibraries() { | |||
2458 | ListScope D(W, "NeededLibraries"); | |||
2459 | ||||
2460 | std::vector<StringRef> Libs; | |||
2461 | for (const auto &Entry : dynamic_table()) | |||
2462 | if (Entry.d_tag == ELF::DT_NEEDED) | |||
2463 | Libs.push_back(getDynamicString(Entry.d_un.d_val)); | |||
2464 | ||||
2465 | llvm::sort(Libs); | |||
2466 | ||||
2467 | for (StringRef L : Libs) | |||
2468 | W.startLine() << L << "\n"; | |||
2469 | } | |||
2470 | ||||
2471 | template <class ELFT> | |||
2472 | static Error checkHashTable(const ELFDumper<ELFT> &Dumper, | |||
2473 | const typename ELFT::Hash *H, | |||
2474 | bool *IsHeaderValid = nullptr) { | |||
2475 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
2476 | const uint64_t SecOffset = (const uint8_t *)H - Obj.base(); | |||
2477 | if (Dumper.getHashTableEntSize() == 8) { | |||
2478 | auto It = llvm::find_if(ElfMachineType, [&](const EnumEntry<unsigned> &E) { | |||
2479 | return E.Value == Obj.getHeader().e_machine; | |||
2480 | }); | |||
2481 | if (IsHeaderValid) | |||
2482 | *IsHeaderValid = false; | |||
2483 | return createError("the hash table at 0x" + Twine::utohexstr(SecOffset) + | |||
2484 | " is not supported: it contains non-standard 8 " | |||
2485 | "byte entries on " + | |||
2486 | It->AltName + " platform"); | |||
2487 | } | |||
2488 | ||||
2489 | auto MakeError = [&](const Twine &Msg = "") { | |||
2490 | return createError("the hash table at offset 0x" + | |||
2491 | Twine::utohexstr(SecOffset) + | |||
2492 | " goes past the end of the file (0x" + | |||
2493 | Twine::utohexstr(Obj.getBufSize()) + ")" + Msg); | |||
2494 | }; | |||
2495 | ||||
2496 | // Each SHT_HASH section starts from two 32-bit fields: nbucket and nchain. | |||
2497 | const unsigned HeaderSize = 2 * sizeof(typename ELFT::Word); | |||
2498 | ||||
2499 | if (IsHeaderValid) | |||
2500 | *IsHeaderValid = Obj.getBufSize() - SecOffset >= HeaderSize; | |||
2501 | ||||
2502 | if (Obj.getBufSize() - SecOffset < HeaderSize) | |||
2503 | return MakeError(); | |||
2504 | ||||
2505 | if (Obj.getBufSize() - SecOffset - HeaderSize < | |||
2506 | ((uint64_t)H->nbucket + H->nchain) * sizeof(typename ELFT::Word)) | |||
2507 | return MakeError(", nbucket = " + Twine(H->nbucket) + | |||
2508 | ", nchain = " + Twine(H->nchain)); | |||
2509 | return Error::success(); | |||
2510 | } | |||
2511 | ||||
2512 | template <class ELFT> | |||
2513 | static Error checkGNUHashTable(const ELFFile<ELFT> &Obj, | |||
2514 | const typename ELFT::GnuHash *GnuHashTable, | |||
2515 | bool *IsHeaderValid = nullptr) { | |||
2516 | const uint8_t *TableData = reinterpret_cast<const uint8_t *>(GnuHashTable); | |||
2517 | 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", 2518, __extension__ __PRETTY_FUNCTION__)) | |||
2518 | "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", 2518, __extension__ __PRETTY_FUNCTION__)); | |||
2519 | ||||
2520 | uint64_t TableOffset = TableData - Obj.base(); | |||
2521 | if (IsHeaderValid) | |||
2522 | *IsHeaderValid = TableOffset + /*Header size:*/ 16 < Obj.getBufSize(); | |||
2523 | if (TableOffset + 16 + (uint64_t)GnuHashTable->nbuckets * 4 + | |||
2524 | (uint64_t)GnuHashTable->maskwords * sizeof(typename ELFT::Off) >= | |||
2525 | Obj.getBufSize()) | |||
2526 | return createError("unable to dump the SHT_GNU_HASH " | |||
2527 | "section at 0x" + | |||
2528 | Twine::utohexstr(TableOffset) + | |||
2529 | ": it goes past the end of the file"); | |||
2530 | return Error::success(); | |||
2531 | } | |||
2532 | ||||
2533 | template <typename ELFT> void ELFDumper<ELFT>::printHashTable() { | |||
2534 | DictScope D(W, "HashTable"); | |||
2535 | if (!HashTable) | |||
2536 | return; | |||
2537 | ||||
2538 | bool IsHeaderValid; | |||
2539 | Error Err = checkHashTable(*this, HashTable, &IsHeaderValid); | |||
2540 | if (IsHeaderValid) { | |||
2541 | W.printNumber("Num Buckets", HashTable->nbucket); | |||
2542 | W.printNumber("Num Chains", HashTable->nchain); | |||
2543 | } | |||
2544 | ||||
2545 | if (Err) { | |||
2546 | reportUniqueWarning(std::move(Err)); | |||
2547 | return; | |||
2548 | } | |||
2549 | ||||
2550 | W.printList("Buckets", HashTable->buckets()); | |||
2551 | W.printList("Chains", HashTable->chains()); | |||
2552 | } | |||
2553 | ||||
2554 | template <class ELFT> | |||
2555 | static Expected<ArrayRef<typename ELFT::Word>> | |||
2556 | getGnuHashTableChains(Optional<DynRegionInfo> DynSymRegion, | |||
2557 | const typename ELFT::GnuHash *GnuHashTable) { | |||
2558 | if (!DynSymRegion) | |||
2559 | return createError("no dynamic symbol table found"); | |||
2560 | ||||
2561 | ArrayRef<typename ELFT::Sym> DynSymTable = | |||
2562 | DynSymRegion->template getAsArrayRef<typename ELFT::Sym>(); | |||
2563 | size_t NumSyms = DynSymTable.size(); | |||
2564 | if (!NumSyms) | |||
2565 | return createError("the dynamic symbol table is empty"); | |||
2566 | ||||
2567 | if (GnuHashTable->symndx < NumSyms) | |||
2568 | return GnuHashTable->values(NumSyms); | |||
2569 | ||||
2570 | // A normal empty GNU hash table section produced by linker might have | |||
2571 | // symndx set to the number of dynamic symbols + 1 (for the zero symbol) | |||
2572 | // and have dummy null values in the Bloom filter and in the buckets | |||
2573 | // vector (or no values at all). It happens because the value of symndx is not | |||
2574 | // important for dynamic loaders when the GNU hash table is empty. They just | |||
2575 | // skip the whole object during symbol lookup. In such cases, the symndx value | |||
2576 | // is irrelevant and we should not report a warning. | |||
2577 | ArrayRef<typename ELFT::Word> Buckets = GnuHashTable->buckets(); | |||
2578 | if (!llvm::all_of(Buckets, [](typename ELFT::Word V) { return V == 0; })) | |||
2579 | return createError( | |||
2580 | "the first hashed symbol index (" + Twine(GnuHashTable->symndx) + | |||
2581 | ") is greater than or equal to the number of dynamic symbols (" + | |||
2582 | Twine(NumSyms) + ")"); | |||
2583 | // There is no way to represent an array of (dynamic symbols count - symndx) | |||
2584 | // length. | |||
2585 | return ArrayRef<typename ELFT::Word>(); | |||
2586 | } | |||
2587 | ||||
2588 | template <typename ELFT> | |||
2589 | void ELFDumper<ELFT>::printGnuHashTable() { | |||
2590 | DictScope D(W, "GnuHashTable"); | |||
2591 | if (!GnuHashTable) | |||
2592 | return; | |||
2593 | ||||
2594 | bool IsHeaderValid; | |||
2595 | Error Err = checkGNUHashTable<ELFT>(Obj, GnuHashTable, &IsHeaderValid); | |||
2596 | if (IsHeaderValid) { | |||
2597 | W.printNumber("Num Buckets", GnuHashTable->nbuckets); | |||
2598 | W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); | |||
2599 | W.printNumber("Num Mask Words", GnuHashTable->maskwords); | |||
2600 | W.printNumber("Shift Count", GnuHashTable->shift2); | |||
2601 | } | |||
2602 | ||||
2603 | if (Err) { | |||
2604 | reportUniqueWarning(std::move(Err)); | |||
2605 | return; | |||
2606 | } | |||
2607 | ||||
2608 | ArrayRef<typename ELFT::Off> BloomFilter = GnuHashTable->filter(); | |||
2609 | W.printHexList("Bloom Filter", BloomFilter); | |||
2610 | ||||
2611 | ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets(); | |||
2612 | W.printList("Buckets", Buckets); | |||
2613 | ||||
2614 | Expected<ArrayRef<Elf_Word>> Chains = | |||
2615 | getGnuHashTableChains<ELFT>(DynSymRegion, GnuHashTable); | |||
2616 | if (!Chains) { | |||
2617 | reportUniqueWarning("unable to dump 'Values' for the SHT_GNU_HASH " | |||
2618 | "section: " + | |||
2619 | toString(Chains.takeError())); | |||
2620 | return; | |||
2621 | } | |||
2622 | ||||
2623 | W.printHexList("Values", *Chains); | |||
2624 | } | |||
2625 | ||||
2626 | template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { | |||
2627 | StringRef SOName = "<Not found>"; | |||
2628 | if (SONameOffset) | |||
2629 | SOName = getDynamicString(*SONameOffset); | |||
2630 | W.printString("LoadName", SOName); | |||
2631 | } | |||
2632 | ||||
2633 | template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() { | |||
2634 | switch (Obj.getHeader().e_machine) { | |||
2635 | case EM_ARM: | |||
2636 | if (Obj.isLE()) | |||
2637 | printAttributes(ELF::SHT_ARM_ATTRIBUTES, | |||
2638 | std::make_unique<ARMAttributeParser>(&W), | |||
2639 | support::little); | |||
2640 | else | |||
2641 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2642 | "ARM objects"); | |||
2643 | break; | |||
2644 | case EM_RISCV: | |||
2645 | if (Obj.isLE()) | |||
2646 | printAttributes(ELF::SHT_RISCV_ATTRIBUTES, | |||
2647 | std::make_unique<RISCVAttributeParser>(&W), | |||
2648 | support::little); | |||
2649 | else | |||
2650 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2651 | "RISC-V objects"); | |||
2652 | break; | |||
2653 | case EM_MSP430: | |||
2654 | printAttributes(ELF::SHT_MSP430_ATTRIBUTES, | |||
2655 | std::make_unique<MSP430AttributeParser>(&W), | |||
2656 | support::little); | |||
2657 | break; | |||
2658 | case EM_MIPS: { | |||
2659 | printMipsABIFlags(); | |||
2660 | printMipsOptions(); | |||
2661 | printMipsReginfo(); | |||
2662 | MipsGOTParser<ELFT> Parser(*this); | |||
2663 | if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols())) | |||
2664 | reportUniqueWarning(std::move(E)); | |||
2665 | else if (!Parser.isGotEmpty()) | |||
2666 | printMipsGOT(Parser); | |||
2667 | ||||
2668 | if (Error E = Parser.findPLT(dynamic_table())) | |||
2669 | reportUniqueWarning(std::move(E)); | |||
2670 | else if (!Parser.isPltEmpty()) | |||
2671 | printMipsPLT(Parser); | |||
2672 | break; | |||
2673 | } | |||
2674 | default: | |||
2675 | break; | |||
2676 | } | |||
2677 | } | |||
2678 | ||||
2679 | template <class ELFT> | |||
2680 | void ELFDumper<ELFT>::printAttributes( | |||
2681 | unsigned AttrShType, std::unique_ptr<ELFAttributeParser> AttrParser, | |||
2682 | support::endianness Endianness) { | |||
2683 | 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", 2684, __extension__ __PRETTY_FUNCTION__)) | |||
2684 | "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", 2684, __extension__ __PRETTY_FUNCTION__)); | |||
2685 | DictScope BA(W, "BuildAttributes"); | |||
2686 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
2687 | if (Sec.sh_type != AttrShType) | |||
2688 | continue; | |||
2689 | ||||
2690 | ArrayRef<uint8_t> Contents; | |||
2691 | if (Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
2692 | Obj.getSectionContents(Sec)) { | |||
2693 | Contents = *ContentOrErr; | |||
2694 | if (Contents.empty()) { | |||
2695 | reportUniqueWarning("the " + describe(Sec) + " is empty"); | |||
2696 | continue; | |||
2697 | } | |||
2698 | } else { | |||
2699 | reportUniqueWarning("unable to read the content of the " + describe(Sec) + | |||
2700 | ": " + toString(ContentOrErr.takeError())); | |||
2701 | continue; | |||
2702 | } | |||
2703 | ||||
2704 | W.printHex("FormatVersion", Contents[0]); | |||
2705 | ||||
2706 | if (Error E = AttrParser->parse(Contents, Endianness)) | |||
2707 | reportUniqueWarning("unable to dump attributes from the " + | |||
2708 | describe(Sec) + ": " + toString(std::move(E))); | |||
2709 | } | |||
2710 | } | |||
2711 | ||||
2712 | namespace { | |||
2713 | ||||
2714 | template <class ELFT> class MipsGOTParser { | |||
2715 | public: | |||
2716 | 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_Chdr = typename ELFT::Chdr; 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; | |||
2717 | using Entry = typename ELFT::Addr; | |||
2718 | using Entries = ArrayRef<Entry>; | |||
2719 | ||||
2720 | const bool IsStatic; | |||
2721 | const ELFFile<ELFT> &Obj; | |||
2722 | const ELFDumper<ELFT> &Dumper; | |||
2723 | ||||
2724 | MipsGOTParser(const ELFDumper<ELFT> &D); | |||
2725 | Error findGOT(Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms); | |||
2726 | Error findPLT(Elf_Dyn_Range DynTable); | |||
2727 | ||||
2728 | bool isGotEmpty() const { return GotEntries.empty(); } | |||
2729 | bool isPltEmpty() const { return PltEntries.empty(); } | |||
2730 | ||||
2731 | uint64_t getGp() const; | |||
2732 | ||||
2733 | const Entry *getGotLazyResolver() const; | |||
2734 | const Entry *getGotModulePointer() const; | |||
2735 | const Entry *getPltLazyResolver() const; | |||
2736 | const Entry *getPltModulePointer() const; | |||
2737 | ||||
2738 | Entries getLocalEntries() const; | |||
2739 | Entries getGlobalEntries() const; | |||
2740 | Entries getOtherEntries() const; | |||
2741 | Entries getPltEntries() const; | |||
2742 | ||||
2743 | uint64_t getGotAddress(const Entry * E) const; | |||
2744 | int64_t getGotOffset(const Entry * E) const; | |||
2745 | const Elf_Sym *getGotSym(const Entry *E) const; | |||
2746 | ||||
2747 | uint64_t getPltAddress(const Entry * E) const; | |||
2748 | const Elf_Sym *getPltSym(const Entry *E) const; | |||
2749 | ||||
2750 | StringRef getPltStrTable() const { return PltStrTable; } | |||
2751 | const Elf_Shdr *getPltSymTable() const { return PltSymTable; } | |||
2752 | ||||
2753 | private: | |||
2754 | const Elf_Shdr *GotSec; | |||
2755 | size_t LocalNum; | |||
2756 | size_t GlobalNum; | |||
2757 | ||||
2758 | const Elf_Shdr *PltSec; | |||
2759 | const Elf_Shdr *PltRelSec; | |||
2760 | const Elf_Shdr *PltSymTable; | |||
2761 | StringRef FileName; | |||
2762 | ||||
2763 | Elf_Sym_Range GotDynSyms; | |||
2764 | StringRef PltStrTable; | |||
2765 | ||||
2766 | Entries GotEntries; | |||
2767 | Entries PltEntries; | |||
2768 | }; | |||
2769 | ||||
2770 | } // end anonymous namespace | |||
2771 | ||||
2772 | template <class ELFT> | |||
2773 | MipsGOTParser<ELFT>::MipsGOTParser(const ELFDumper<ELFT> &D) | |||
2774 | : IsStatic(D.dynamic_table().empty()), Obj(D.getElfObject().getELFFile()), | |||
2775 | Dumper(D), GotSec(nullptr), LocalNum(0), GlobalNum(0), PltSec(nullptr), | |||
2776 | PltRelSec(nullptr), PltSymTable(nullptr), | |||
2777 | FileName(D.getElfObject().getFileName()) {} | |||
2778 | ||||
2779 | template <class ELFT> | |||
2780 | Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable, | |||
2781 | Elf_Sym_Range DynSyms) { | |||
2782 | // See "Global Offset Table" in Chapter 5 in the following document | |||
2783 | // for detailed GOT description. | |||
2784 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
2785 | ||||
2786 | // Find static GOT secton. | |||
2787 | if (IsStatic) { | |||
2788 | GotSec = Dumper.findSectionByName(".got"); | |||
2789 | if (!GotSec) | |||
2790 | return Error::success(); | |||
2791 | ||||
2792 | ArrayRef<uint8_t> Content = | |||
2793 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
2794 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
2795 | Content.size() / sizeof(Entry)); | |||
2796 | LocalNum = GotEntries.size(); | |||
2797 | return Error::success(); | |||
2798 | } | |||
2799 | ||||
2800 | // Lookup dynamic table tags which define the GOT layout. | |||
2801 | std::optional<uint64_t> DtPltGot; | |||
2802 | std::optional<uint64_t> DtLocalGotNum; | |||
2803 | std::optional<uint64_t> DtGotSym; | |||
2804 | for (const auto &Entry : DynTable) { | |||
2805 | switch (Entry.getTag()) { | |||
2806 | case ELF::DT_PLTGOT: | |||
2807 | DtPltGot = Entry.getVal(); | |||
2808 | break; | |||
2809 | case ELF::DT_MIPS_LOCAL_GOTNO: | |||
2810 | DtLocalGotNum = Entry.getVal(); | |||
2811 | break; | |||
2812 | case ELF::DT_MIPS_GOTSYM: | |||
2813 | DtGotSym = Entry.getVal(); | |||
2814 | break; | |||
2815 | } | |||
2816 | } | |||
2817 | ||||
2818 | if (!DtPltGot && !DtLocalGotNum && !DtGotSym) | |||
2819 | return Error::success(); | |||
2820 | ||||
2821 | if (!DtPltGot) | |||
2822 | return createError("cannot find PLTGOT dynamic tag"); | |||
2823 | if (!DtLocalGotNum) | |||
2824 | return createError("cannot find MIPS_LOCAL_GOTNO dynamic tag"); | |||
2825 | if (!DtGotSym) | |||
2826 | return createError("cannot find MIPS_GOTSYM dynamic tag"); | |||
2827 | ||||
2828 | size_t DynSymTotal = DynSyms.size(); | |||
2829 | if (*DtGotSym > DynSymTotal) | |||
2830 | return createError("DT_MIPS_GOTSYM value (" + Twine(*DtGotSym) + | |||
2831 | ") exceeds the number of dynamic symbols (" + | |||
2832 | Twine(DynSymTotal) + ")"); | |||
2833 | ||||
2834 | GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot); | |||
2835 | if (!GotSec) | |||
2836 | return createError("there is no non-empty GOT section at 0x" + | |||
2837 | Twine::utohexstr(*DtPltGot)); | |||
2838 | ||||
2839 | LocalNum = *DtLocalGotNum; | |||
2840 | GlobalNum = DynSymTotal - *DtGotSym; | |||
2841 | ||||
2842 | ArrayRef<uint8_t> Content = | |||
2843 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
2844 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
2845 | Content.size() / sizeof(Entry)); | |||
2846 | GotDynSyms = DynSyms.drop_front(*DtGotSym); | |||
2847 | ||||
2848 | return Error::success(); | |||
2849 | } | |||
2850 | ||||
2851 | template <class ELFT> | |||
2852 | Error MipsGOTParser<ELFT>::findPLT(Elf_Dyn_Range DynTable) { | |||
2853 | // Lookup dynamic table tags which define the PLT layout. | |||
2854 | std::optional<uint64_t> DtMipsPltGot; | |||
2855 | std::optional<uint64_t> DtJmpRel; | |||
2856 | for (const auto &Entry : DynTable) { | |||
2857 | switch (Entry.getTag()) { | |||
2858 | case ELF::DT_MIPS_PLTGOT: | |||
2859 | DtMipsPltGot = Entry.getVal(); | |||
2860 | break; | |||
2861 | case ELF::DT_JMPREL: | |||
2862 | DtJmpRel = Entry.getVal(); | |||
2863 | break; | |||
2864 | } | |||
2865 | } | |||
2866 | ||||
2867 | if (!DtMipsPltGot && !DtJmpRel) | |||
2868 | return Error::success(); | |||
2869 | ||||
2870 | // Find PLT section. | |||
2871 | if (!DtMipsPltGot) | |||
2872 | return createError("cannot find MIPS_PLTGOT dynamic tag"); | |||
2873 | if (!DtJmpRel) | |||
2874 | return createError("cannot find JMPREL dynamic tag"); | |||
2875 | ||||
2876 | PltSec = findNotEmptySectionByAddress(Obj, FileName, *DtMipsPltGot); | |||
2877 | if (!PltSec) | |||
2878 | return createError("there is no non-empty PLTGOT section at 0x" + | |||
2879 | Twine::utohexstr(*DtMipsPltGot)); | |||
2880 | ||||
2881 | PltRelSec = findNotEmptySectionByAddress(Obj, FileName, *DtJmpRel); | |||
2882 | if (!PltRelSec) | |||
2883 | return createError("there is no non-empty RELPLT section at 0x" + | |||
2884 | Twine::utohexstr(*DtJmpRel)); | |||
2885 | ||||
2886 | if (Expected<ArrayRef<uint8_t>> PltContentOrErr = | |||
2887 | Obj.getSectionContents(*PltSec)) | |||
2888 | PltEntries = | |||
2889 | Entries(reinterpret_cast<const Entry *>(PltContentOrErr->data()), | |||
2890 | PltContentOrErr->size() / sizeof(Entry)); | |||
2891 | else | |||
2892 | return createError("unable to read PLTGOT section content: " + | |||
2893 | toString(PltContentOrErr.takeError())); | |||
2894 | ||||
2895 | if (Expected<const Elf_Shdr *> PltSymTableOrErr = | |||
2896 | Obj.getSection(PltRelSec->sh_link)) | |||
2897 | PltSymTable = *PltSymTableOrErr; | |||
2898 | else | |||
2899 | return createError("unable to get a symbol table linked to the " + | |||
2900 | describe(Obj, *PltRelSec) + ": " + | |||
2901 | toString(PltSymTableOrErr.takeError())); | |||
2902 | ||||
2903 | if (Expected<StringRef> StrTabOrErr = | |||
2904 | Obj.getStringTableForSymtab(*PltSymTable)) | |||
2905 | PltStrTable = *StrTabOrErr; | |||
2906 | else | |||
2907 | return createError("unable to get a string table for the " + | |||
2908 | describe(Obj, *PltSymTable) + ": " + | |||
2909 | toString(StrTabOrErr.takeError())); | |||
2910 | ||||
2911 | return Error::success(); | |||
2912 | } | |||
2913 | ||||
2914 | template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const { | |||
2915 | return GotSec->sh_addr + 0x7ff0; | |||
2916 | } | |||
2917 | ||||
2918 | template <class ELFT> | |||
2919 | const typename MipsGOTParser<ELFT>::Entry * | |||
2920 | MipsGOTParser<ELFT>::getGotLazyResolver() const { | |||
2921 | return LocalNum > 0 ? &GotEntries[0] : nullptr; | |||
2922 | } | |||
2923 | ||||
2924 | template <class ELFT> | |||
2925 | const typename MipsGOTParser<ELFT>::Entry * | |||
2926 | MipsGOTParser<ELFT>::getGotModulePointer() const { | |||
2927 | if (LocalNum < 2) | |||
2928 | return nullptr; | |||
2929 | const Entry &E = GotEntries[1]; | |||
2930 | if ((E >> (sizeof(Entry) * 8 - 1)) == 0) | |||
2931 | return nullptr; | |||
2932 | return &E; | |||
2933 | } | |||
2934 | ||||
2935 | template <class ELFT> | |||
2936 | typename MipsGOTParser<ELFT>::Entries | |||
2937 | MipsGOTParser<ELFT>::getLocalEntries() const { | |||
2938 | size_t Skip = getGotModulePointer() ? 2 : 1; | |||
2939 | if (LocalNum - Skip <= 0) | |||
2940 | return Entries(); | |||
2941 | return GotEntries.slice(Skip, LocalNum - Skip); | |||
2942 | } | |||
2943 | ||||
2944 | template <class ELFT> | |||
2945 | typename MipsGOTParser<ELFT>::Entries | |||
2946 | MipsGOTParser<ELFT>::getGlobalEntries() const { | |||
2947 | if (GlobalNum == 0) | |||
2948 | return Entries(); | |||
2949 | return GotEntries.slice(LocalNum, GlobalNum); | |||
2950 | } | |||
2951 | ||||
2952 | template <class ELFT> | |||
2953 | typename MipsGOTParser<ELFT>::Entries | |||
2954 | MipsGOTParser<ELFT>::getOtherEntries() const { | |||
2955 | size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum; | |||
2956 | if (OtherNum == 0) | |||
2957 | return Entries(); | |||
2958 | return GotEntries.slice(LocalNum + GlobalNum, OtherNum); | |||
2959 | } | |||
2960 | ||||
2961 | template <class ELFT> | |||
2962 | uint64_t MipsGOTParser<ELFT>::getGotAddress(const Entry *E) const { | |||
2963 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
2964 | return GotSec->sh_addr + Offset; | |||
2965 | } | |||
2966 | ||||
2967 | template <class ELFT> | |||
2968 | int64_t MipsGOTParser<ELFT>::getGotOffset(const Entry *E) const { | |||
2969 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
2970 | return Offset - 0x7ff0; | |||
2971 | } | |||
2972 | ||||
2973 | template <class ELFT> | |||
2974 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
2975 | MipsGOTParser<ELFT>::getGotSym(const Entry *E) const { | |||
2976 | int64_t Offset = std::distance(GotEntries.data(), E); | |||
2977 | return &GotDynSyms[Offset - LocalNum]; | |||
2978 | } | |||
2979 | ||||
2980 | template <class ELFT> | |||
2981 | const typename MipsGOTParser<ELFT>::Entry * | |||
2982 | MipsGOTParser<ELFT>::getPltLazyResolver() const { | |||
2983 | return PltEntries.empty() ? nullptr : &PltEntries[0]; | |||
2984 | } | |||
2985 | ||||
2986 | template <class ELFT> | |||
2987 | const typename MipsGOTParser<ELFT>::Entry * | |||
2988 | MipsGOTParser<ELFT>::getPltModulePointer() const { | |||
2989 | return PltEntries.size() < 2 ? nullptr : &PltEntries[1]; | |||
2990 | } | |||
2991 | ||||
2992 | template <class ELFT> | |||
2993 | typename MipsGOTParser<ELFT>::Entries | |||
2994 | MipsGOTParser<ELFT>::getPltEntries() const { | |||
2995 | if (PltEntries.size() <= 2) | |||
2996 | return Entries(); | |||
2997 | return PltEntries.slice(2, PltEntries.size() - 2); | |||
2998 | } | |||
2999 | ||||
3000 | template <class ELFT> | |||
3001 | uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const { | |||
3002 | int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry); | |||
3003 | return PltSec->sh_addr + Offset; | |||
3004 | } | |||
3005 | ||||
3006 | template <class ELFT> | |||
3007 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
3008 | MipsGOTParser<ELFT>::getPltSym(const Entry *E) const { | |||
3009 | int64_t Offset = std::distance(getPltEntries().data(), E); | |||
3010 | if (PltRelSec->sh_type == ELF::SHT_REL) { | |||
3011 | Elf_Rel_Range Rels = unwrapOrError(FileName, Obj.rels(*PltRelSec)); | |||
3012 | return unwrapOrError(FileName, | |||
3013 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
3014 | } else { | |||
3015 | Elf_Rela_Range Rels = unwrapOrError(FileName, Obj.relas(*PltRelSec)); | |||
3016 | return unwrapOrError(FileName, | |||
3017 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
3018 | } | |||
3019 | } | |||
3020 | ||||
3021 | const EnumEntry<unsigned> ElfMipsISAExtType[] = { | |||
3022 | {"None", Mips::AFL_EXT_NONE}, | |||
3023 | {"Broadcom SB-1", Mips::AFL_EXT_SB1}, | |||
3024 | {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, | |||
3025 | {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, | |||
3026 | {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, | |||
3027 | {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, | |||
3028 | {"LSI R4010", Mips::AFL_EXT_4010}, | |||
3029 | {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, | |||
3030 | {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, | |||
3031 | {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, | |||
3032 | {"MIPS R4650", Mips::AFL_EXT_4650}, | |||
3033 | {"MIPS R5900", Mips::AFL_EXT_5900}, | |||
3034 | {"MIPS R10000", Mips::AFL_EXT_10000}, | |||
3035 | {"NEC VR4100", Mips::AFL_EXT_4100}, | |||
3036 | {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, | |||
3037 | {"NEC VR4120", Mips::AFL_EXT_4120}, | |||
3038 | {"NEC VR5400", Mips::AFL_EXT_5400}, | |||
3039 | {"NEC VR5500", Mips::AFL_EXT_5500}, | |||
3040 | {"RMI Xlr", Mips::AFL_EXT_XLR}, | |||
3041 | {"Toshiba R3900", Mips::AFL_EXT_3900} | |||
3042 | }; | |||
3043 | ||||
3044 | const EnumEntry<unsigned> ElfMipsASEFlags[] = { | |||
3045 | {"DSP", Mips::AFL_ASE_DSP}, | |||
3046 | {"DSPR2", Mips::AFL_ASE_DSPR2}, | |||
3047 | {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, | |||
3048 | {"MCU", Mips::AFL_ASE_MCU}, | |||
3049 | {"MDMX", Mips::AFL_ASE_MDMX}, | |||
3050 | {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, | |||
3051 | {"MT", Mips::AFL_ASE_MT}, | |||
3052 | {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, | |||
3053 | {"VZ", Mips::AFL_ASE_VIRT}, | |||
3054 | {"MSA", Mips::AFL_ASE_MSA}, | |||
3055 | {"MIPS16", Mips::AFL_ASE_MIPS16}, | |||
3056 | {"microMIPS", Mips::AFL_ASE_MICROMIPS}, | |||
3057 | {"XPA", Mips::AFL_ASE_XPA}, | |||
3058 | {"CRC", Mips::AFL_ASE_CRC}, | |||
3059 | {"GINV", Mips::AFL_ASE_GINV}, | |||
3060 | }; | |||
3061 | ||||
3062 | const EnumEntry<unsigned> ElfMipsFpABIType[] = { | |||
3063 | {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, | |||
3064 | {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, | |||
3065 | {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, | |||
3066 | {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, | |||
3067 | {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", | |||
3068 | Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, | |||
3069 | {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, | |||
3070 | {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, | |||
3071 | {"Hard float compat (32-bit CPU, 64-bit FPU)", | |||
3072 | Mips::Val_GNU_MIPS_ABI_FP_64A} | |||
3073 | }; | |||
3074 | ||||
3075 | static const EnumEntry<unsigned> ElfMipsFlags1[] { | |||
3076 | {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, | |||
3077 | }; | |||
3078 | ||||
3079 | static int getMipsRegisterSize(uint8_t Flag) { | |||
3080 | switch (Flag) { | |||
3081 | case Mips::AFL_REG_NONE: | |||
3082 | return 0; | |||
3083 | case Mips::AFL_REG_32: | |||
3084 | return 32; | |||
3085 | case Mips::AFL_REG_64: | |||
3086 | return 64; | |||
3087 | case Mips::AFL_REG_128: | |||
3088 | return 128; | |||
3089 | default: | |||
3090 | return -1; | |||
3091 | } | |||
3092 | } | |||
3093 | ||||
3094 | template <class ELFT> | |||
3095 | static void printMipsReginfoData(ScopedPrinter &W, | |||
3096 | const Elf_Mips_RegInfo<ELFT> &Reginfo) { | |||
3097 | W.printHex("GP", Reginfo.ri_gp_value); | |||
3098 | W.printHex("General Mask", Reginfo.ri_gprmask); | |||
3099 | W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); | |||
3100 | W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); | |||
3101 | W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); | |||
3102 | W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); | |||
3103 | } | |||
3104 | ||||
3105 | template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { | |||
3106 | const Elf_Shdr *RegInfoSec = findSectionByName(".reginfo"); | |||
3107 | if (!RegInfoSec) { | |||
3108 | W.startLine() << "There is no .reginfo section in the file.\n"; | |||
3109 | return; | |||
3110 | } | |||
3111 | ||||
3112 | Expected<ArrayRef<uint8_t>> ContentsOrErr = | |||
3113 | Obj.getSectionContents(*RegInfoSec); | |||
3114 | if (!ContentsOrErr) { | |||
3115 | this->reportUniqueWarning( | |||
3116 | "unable to read the content of the .reginfo section (" + | |||
3117 | describe(*RegInfoSec) + "): " + toString(ContentsOrErr.takeError())); | |||
3118 | return; | |||
3119 | } | |||
3120 | ||||
3121 | if (ContentsOrErr->size() < sizeof(Elf_Mips_RegInfo<ELFT>)) { | |||
3122 | this->reportUniqueWarning("the .reginfo section has an invalid size (0x" + | |||
3123 | Twine::utohexstr(ContentsOrErr->size()) + ")"); | |||
3124 | return; | |||
3125 | } | |||
3126 | ||||
3127 | DictScope GS(W, "MIPS RegInfo"); | |||
3128 | printMipsReginfoData(W, *reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>( | |||
3129 | ContentsOrErr->data())); | |||
3130 | } | |||
3131 | ||||
3132 | template <class ELFT> | |||
3133 | static Expected<const Elf_Mips_Options<ELFT> *> | |||
3134 | readMipsOptions(const uint8_t *SecBegin, ArrayRef<uint8_t> &SecData, | |||
3135 | bool &IsSupported) { | |||
3136 | if (SecData.size() < sizeof(Elf_Mips_Options<ELFT>)) | |||
3137 | return createError("the .MIPS.options section has an invalid size (0x" + | |||
3138 | Twine::utohexstr(SecData.size()) + ")"); | |||
3139 | ||||
3140 | const Elf_Mips_Options<ELFT> *O = | |||
3141 | reinterpret_cast<const Elf_Mips_Options<ELFT> *>(SecData.data()); | |||
3142 | const uint8_t Size = O->size; | |||
3143 | if (Size > SecData.size()) { | |||
3144 | const uint64_t Offset = SecData.data() - SecBegin; | |||
3145 | const uint64_t SecSize = Offset + SecData.size(); | |||
3146 | return createError("a descriptor of size 0x" + Twine::utohexstr(Size) + | |||
3147 | " at offset 0x" + Twine::utohexstr(Offset) + | |||
3148 | " goes past the end of the .MIPS.options " | |||
3149 | "section of size 0x" + | |||
3150 | Twine::utohexstr(SecSize)); | |||
3151 | } | |||
3152 | ||||
3153 | IsSupported = O->kind == ODK_REGINFO; | |||
3154 | const size_t ExpectedSize = | |||
3155 | sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>); | |||
3156 | ||||
3157 | if (IsSupported) | |||
3158 | if (Size < ExpectedSize) | |||
3159 | return createError( | |||
3160 | "a .MIPS.options entry of kind " + | |||
3161 | Twine(getElfMipsOptionsOdkType(O->kind)) + | |||
3162 | " has an invalid size (0x" + Twine::utohexstr(Size) + | |||
3163 | "), the expected size is 0x" + Twine::utohexstr(ExpectedSize)); | |||
3164 | ||||
3165 | SecData = SecData.drop_front(Size); | |||
3166 | return O; | |||
3167 | } | |||
3168 | ||||
3169 | template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() { | |||
3170 | const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options"); | |||
3171 | if (!MipsOpts) { | |||
3172 | W.startLine() << "There is no .MIPS.options section in the file.\n"; | |||
3173 | return; | |||
3174 | } | |||
3175 | ||||
3176 | DictScope GS(W, "MIPS Options"); | |||
3177 | ||||
3178 | ArrayRef<uint8_t> Data = | |||
3179 | unwrapOrError(ObjF.getFileName(), Obj.getSectionContents(*MipsOpts)); | |||
3180 | const uint8_t *const SecBegin = Data.begin(); | |||
3181 | while (!Data.empty()) { | |||
3182 | bool IsSupported; | |||
3183 | Expected<const Elf_Mips_Options<ELFT> *> OptsOrErr = | |||
3184 | readMipsOptions<ELFT>(SecBegin, Data, IsSupported); | |||
3185 | if (!OptsOrErr) { | |||
3186 | reportUniqueWarning(OptsOrErr.takeError()); | |||
3187 | break; | |||
3188 | } | |||
3189 | ||||
3190 | unsigned Kind = (*OptsOrErr)->kind; | |||
3191 | const char *Type = getElfMipsOptionsOdkType(Kind); | |||
3192 | if (!IsSupported) { | |||
3193 | W.startLine() << "Unsupported MIPS options tag: " << Type << " (" << Kind | |||
3194 | << ")\n"; | |||
3195 | continue; | |||
3196 | } | |||
3197 | ||||
3198 | DictScope GS(W, Type); | |||
3199 | if (Kind == ODK_REGINFO) | |||
3200 | printMipsReginfoData(W, (*OptsOrErr)->getRegInfo()); | |||
3201 | else | |||
3202 | llvm_unreachable("unexpected .MIPS.options section descriptor kind")::llvm::llvm_unreachable_internal("unexpected .MIPS.options section descriptor kind" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3202); | |||
3203 | } | |||
3204 | } | |||
3205 | ||||
3206 | template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { | |||
3207 | const Elf_Shdr *StackMapSection = findSectionByName(".llvm_stackmaps"); | |||
3208 | if (!StackMapSection) | |||
3209 | return; | |||
3210 | ||||
3211 | auto Warn = [&](Error &&E) { | |||
3212 | this->reportUniqueWarning("unable to read the stack map from " + | |||
3213 | describe(*StackMapSection) + ": " + | |||
3214 | toString(std::move(E))); | |||
3215 | }; | |||
3216 | ||||
3217 | Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
3218 | Obj.getSectionContents(*StackMapSection); | |||
3219 | if (!ContentOrErr) { | |||
3220 | Warn(ContentOrErr.takeError()); | |||
3221 | return; | |||
3222 | } | |||
3223 | ||||
3224 | if (Error E = StackMapParser<ELFT::TargetEndianness>::validateHeader( | |||
3225 | *ContentOrErr)) { | |||
3226 | Warn(std::move(E)); | |||
3227 | return; | |||
3228 | } | |||
3229 | ||||
3230 | prettyPrintStackMap(W, StackMapParser<ELFT::TargetEndianness>(*ContentOrErr)); | |||
3231 | } | |||
3232 | ||||
3233 | template <class ELFT> | |||
3234 | void ELFDumper<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
3235 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab) { | |||
3236 | Expected<RelSymbol<ELFT>> Target = getRelocationTarget(R, SymTab); | |||
3237 | if (!Target) | |||
3238 | reportUniqueWarning("unable to print relocation " + Twine(RelIndex) + | |||
3239 | " in " + describe(Sec) + ": " + | |||
3240 | toString(Target.takeError())); | |||
3241 | else | |||
3242 | printRelRelaReloc(R, *Target); | |||
3243 | } | |||
3244 | ||||
3245 | static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, | |||
3246 | StringRef Str2) { | |||
3247 | OS.PadToColumn(2u); | |||
3248 | OS << Str1; | |||
3249 | OS.PadToColumn(37u); | |||
3250 | OS << Str2 << "\n"; | |||
3251 | OS.flush(); | |||
3252 | } | |||
3253 | ||||
3254 | template <class ELFT> | |||
3255 | static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj, | |||
3256 | StringRef FileName) { | |||
3257 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3258 | if (ElfHeader.e_shnum != 0) | |||
3259 | return to_string(ElfHeader.e_shnum); | |||
3260 | ||||
3261 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3262 | if (!ArrOrErr) { | |||
3263 | // In this case we can ignore an error, because we have already reported a | |||
3264 | // warning about the broken section header table earlier. | |||
3265 | consumeError(ArrOrErr.takeError()); | |||
3266 | return "<?>"; | |||
3267 | } | |||
3268 | ||||
3269 | if (ArrOrErr->empty()) | |||
3270 | return "0"; | |||
3271 | return "0 (" + to_string((*ArrOrErr)[0].sh_size) + ")"; | |||
3272 | } | |||
3273 | ||||
3274 | template <class ELFT> | |||
3275 | static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> &Obj, | |||
3276 | StringRef FileName) { | |||
3277 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3278 | if (ElfHeader.e_shstrndx != SHN_XINDEX) | |||
3279 | return to_string(ElfHeader.e_shstrndx); | |||
3280 | ||||
3281 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3282 | if (!ArrOrErr) { | |||
3283 | // In this case we can ignore an error, because we have already reported a | |||
3284 | // warning about the broken section header table earlier. | |||
3285 | consumeError(ArrOrErr.takeError()); | |||
3286 | return "<?>"; | |||
3287 | } | |||
3288 | ||||
3289 | if (ArrOrErr->empty()) | |||
3290 | return "65535 (corrupt: out of range)"; | |||
3291 | return to_string(ElfHeader.e_shstrndx) + " (" + | |||
3292 | to_string((*ArrOrErr)[0].sh_link) + ")"; | |||
3293 | } | |||
3294 | ||||
3295 | static const EnumEntry<unsigned> *getObjectFileEnumEntry(unsigned Type) { | |||
3296 | auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) { | |||
3297 | return E.Value == Type; | |||
3298 | }); | |||
3299 | if (It != makeArrayRef(ElfObjectFileType).end()) | |||
3300 | return It; | |||
3301 | return nullptr; | |||
3302 | } | |||
3303 | ||||
3304 | template <class ELFT> | |||
3305 | void GNUELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
3306 | ArrayRef<std::string> InputFilenames, | |||
3307 | const Archive *A) { | |||
3308 | if (InputFilenames.size() > 1 || A) { | |||
3309 | this->W.startLine() << "\n"; | |||
3310 | this->W.printString("File", FileStr); | |||
3311 | } | |||
3312 | } | |||
3313 | ||||
3314 | template <class ELFT> void GNUELFDumper<ELFT>::printFileHeaders() { | |||
3315 | const Elf_Ehdr &e = this->Obj.getHeader(); | |||
3316 | OS << "ELF Header:\n"; | |||
3317 | OS << " Magic: "; | |||
3318 | std::string Str; | |||
3319 | for (int i = 0; i < ELF::EI_NIDENT; i++) | |||
3320 | OS << format(" %02x", static_cast<int>(e.e_ident[i])); | |||
3321 | OS << "\n"; | |||
3322 | Str = enumToString(e.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); | |||
3323 | printFields(OS, "Class:", Str); | |||
3324 | Str = enumToString(e.e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); | |||
3325 | printFields(OS, "Data:", Str); | |||
3326 | OS.PadToColumn(2u); | |||
3327 | OS << "Version:"; | |||
3328 | OS.PadToColumn(37u); | |||
3329 | OS << utohexstr(e.e_ident[ELF::EI_VERSION]); | |||
3330 | if (e.e_version == ELF::EV_CURRENT) | |||
3331 | OS << " (current)"; | |||
3332 | OS << "\n"; | |||
3333 | Str = enumToString(e.e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); | |||
3334 | printFields(OS, "OS/ABI:", Str); | |||
3335 | printFields(OS, | |||
3336 | "ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION])); | |||
3337 | ||||
3338 | if (const EnumEntry<unsigned> *E = getObjectFileEnumEntry(e.e_type)) { | |||
3339 | Str = E->AltName.str(); | |||
3340 | } else { | |||
3341 | if (e.e_type >= ET_LOPROC) | |||
3342 | Str = "Processor Specific: (" + utohexstr(e.e_type, /*LowerCase=*/true) + ")"; | |||
3343 | else if (e.e_type >= ET_LOOS) | |||
3344 | Str = "OS Specific: (" + utohexstr(e.e_type, /*LowerCase=*/true) + ")"; | |||
3345 | else | |||
3346 | Str = "<unknown>: " + utohexstr(e.e_type, /*LowerCase=*/true); | |||
3347 | } | |||
3348 | printFields(OS, "Type:", Str); | |||
3349 | ||||
3350 | Str = enumToString(e.e_machine, makeArrayRef(ElfMachineType)); | |||
3351 | printFields(OS, "Machine:", Str); | |||
3352 | Str = "0x" + utohexstr(e.e_version); | |||
3353 | printFields(OS, "Version:", Str); | |||
3354 | Str = "0x" + utohexstr(e.e_entry); | |||
3355 | printFields(OS, "Entry point address:", Str); | |||
3356 | Str = to_string(e.e_phoff) + " (bytes into file)"; | |||
3357 | printFields(OS, "Start of program headers:", Str); | |||
3358 | Str = to_string(e.e_shoff) + " (bytes into file)"; | |||
3359 | printFields(OS, "Start of section headers:", Str); | |||
3360 | std::string ElfFlags; | |||
3361 | if (e.e_machine == EM_MIPS) | |||
3362 | ElfFlags = | |||
3363 | printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags), | |||
3364 | unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), | |||
3365 | unsigned(ELF::EF_MIPS_MACH)); | |||
3366 | else if (e.e_machine == EM_RISCV) | |||
3367 | ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags)); | |||
3368 | else if (e.e_machine == EM_AVR) | |||
3369 | ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderAVRFlags), | |||
3370 | unsigned(ELF::EF_AVR_ARCH_MASK)); | |||
3371 | else if (e.e_machine == EM_LOONGARCH) | |||
3372 | ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderLoongArchFlags), | |||
3373 | unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), | |||
3374 | unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); | |||
3375 | Str = "0x" + utohexstr(e.e_flags); | |||
3376 | if (!ElfFlags.empty()) | |||
3377 | Str = Str + ", " + ElfFlags; | |||
3378 | printFields(OS, "Flags:", Str); | |||
3379 | Str = to_string(e.e_ehsize) + " (bytes)"; | |||
3380 | printFields(OS, "Size of this header:", Str); | |||
3381 | Str = to_string(e.e_phentsize) + " (bytes)"; | |||
3382 | printFields(OS, "Size of program headers:", Str); | |||
3383 | Str = to_string(e.e_phnum); | |||
3384 | printFields(OS, "Number of program headers:", Str); | |||
3385 | Str = to_string(e.e_shentsize) + " (bytes)"; | |||
3386 | printFields(OS, "Size of section headers:", Str); | |||
3387 | Str = getSectionHeadersNumString(this->Obj, this->FileName); | |||
3388 | printFields(OS, "Number of section headers:", Str); | |||
3389 | Str = getSectionHeaderTableIndexString(this->Obj, this->FileName); | |||
3390 | printFields(OS, "Section header string table index:", Str); | |||
3391 | } | |||
3392 | ||||
3393 | template <class ELFT> std::vector<GroupSection> ELFDumper<ELFT>::getGroups() { | |||
3394 | auto GetSignature = [&](const Elf_Sym &Sym, unsigned SymNdx, | |||
3395 | const Elf_Shdr &Symtab) -> StringRef { | |||
3396 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(Symtab); | |||
3397 | if (!StrTableOrErr) { | |||
3398 | reportUniqueWarning("unable to get the string table for " + | |||
3399 | describe(Symtab) + ": " + | |||
3400 | toString(StrTableOrErr.takeError())); | |||
3401 | return "<?>"; | |||
3402 | } | |||
3403 | ||||
3404 | StringRef Strings = *StrTableOrErr; | |||
3405 | if (Sym.st_name >= Strings.size()) { | |||
3406 | reportUniqueWarning("unable to get the name of the symbol with index " + | |||
3407 | Twine(SymNdx) + ": st_name (0x" + | |||
3408 | Twine::utohexstr(Sym.st_name) + | |||
3409 | ") is past the end of the string table of size 0x" + | |||
3410 | Twine::utohexstr(Strings.size())); | |||
3411 | return "<?>"; | |||
3412 | } | |||
3413 | ||||
3414 | return StrTableOrErr->data() + Sym.st_name; | |||
3415 | }; | |||
3416 | ||||
3417 | std::vector<GroupSection> Ret; | |||
3418 | uint64_t I = 0; | |||
3419 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
3420 | ++I; | |||
3421 | if (Sec.sh_type != ELF::SHT_GROUP) | |||
3422 | continue; | |||
3423 | ||||
3424 | StringRef Signature = "<?>"; | |||
3425 | if (Expected<const Elf_Shdr *> SymtabOrErr = Obj.getSection(Sec.sh_link)) { | |||
3426 | if (Expected<const Elf_Sym *> SymOrErr = | |||
3427 | Obj.template getEntry<Elf_Sym>(**SymtabOrErr, Sec.sh_info)) | |||
3428 | Signature = GetSignature(**SymOrErr, Sec.sh_info, **SymtabOrErr); | |||
3429 | else | |||
3430 | reportUniqueWarning("unable to get the signature symbol for " + | |||
3431 | describe(Sec) + ": " + | |||
3432 | toString(SymOrErr.takeError())); | |||
3433 | } else { | |||
3434 | reportUniqueWarning("unable to get the symbol table for " + | |||
3435 | describe(Sec) + ": " + | |||
3436 | toString(SymtabOrErr.takeError())); | |||
3437 | } | |||
3438 | ||||
3439 | ArrayRef<Elf_Word> Data; | |||
3440 | if (Expected<ArrayRef<Elf_Word>> ContentsOrErr = | |||
3441 | Obj.template getSectionContentsAsArray<Elf_Word>(Sec)) { | |||
3442 | if (ContentsOrErr->empty()) | |||
3443 | reportUniqueWarning("unable to read the section group flag from the " + | |||
3444 | describe(Sec) + ": the section is empty"); | |||
3445 | else | |||
3446 | Data = *ContentsOrErr; | |||
3447 | } else { | |||
3448 | reportUniqueWarning("unable to get the content of the " + describe(Sec) + | |||
3449 | ": " + toString(ContentsOrErr.takeError())); | |||
3450 | } | |||
3451 | ||||
3452 | Ret.push_back({getPrintableSectionName(Sec), | |||
3453 | maybeDemangle(Signature), | |||
3454 | Sec.sh_name, | |||
3455 | I - 1, | |||
3456 | Sec.sh_link, | |||
3457 | Sec.sh_info, | |||
3458 | Data.empty() ? Elf_Word(0) : Data[0], | |||
3459 | {}}); | |||
3460 | ||||
3461 | if (Data.empty()) | |||
3462 | continue; | |||
3463 | ||||
3464 | std::vector<GroupMember> &GM = Ret.back().Members; | |||
3465 | for (uint32_t Ndx : Data.slice(1)) { | |||
3466 | if (Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(Ndx)) { | |||
3467 | GM.push_back({getPrintableSectionName(**SecOrErr), Ndx}); | |||
3468 | } else { | |||
3469 | reportUniqueWarning("unable to get the section with index " + | |||
3470 | Twine(Ndx) + " when dumping the " + describe(Sec) + | |||
3471 | ": " + toString(SecOrErr.takeError())); | |||
3472 | GM.push_back({"<?>", Ndx}); | |||
3473 | } | |||
3474 | } | |||
3475 | } | |||
3476 | return Ret; | |||
3477 | } | |||
3478 | ||||
3479 | static DenseMap<uint64_t, const GroupSection *> | |||
3480 | mapSectionsToGroups(ArrayRef<GroupSection> Groups) { | |||
3481 | DenseMap<uint64_t, const GroupSection *> Ret; | |||
3482 | for (const GroupSection &G : Groups) | |||
3483 | for (const GroupMember &GM : G.Members) | |||
3484 | Ret.insert({GM.Index, &G}); | |||
3485 | return Ret; | |||
3486 | } | |||
3487 | ||||
3488 | template <class ELFT> void GNUELFDumper<ELFT>::printGroupSections() { | |||
3489 | std::vector<GroupSection> V = this->getGroups(); | |||
3490 | DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); | |||
3491 | for (const GroupSection &G : V) { | |||
3492 | OS << "\n" | |||
3493 | << getGroupType(G.Type) << " group section [" | |||
3494 | << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature | |||
3495 | << "] contains " << G.Members.size() << " sections:\n" | |||
3496 | << " [Index] Name\n"; | |||
3497 | for (const GroupMember &GM : G.Members) { | |||
3498 | const GroupSection *MainGroup = Map[GM.Index]; | |||
3499 | if (MainGroup != &G) | |||
3500 | this->reportUniqueWarning( | |||
3501 | "section with index " + Twine(GM.Index) + | |||
3502 | ", included in the group section with index " + | |||
3503 | Twine(MainGroup->Index) + | |||
3504 | ", was also found in the group section with index " + | |||
3505 | Twine(G.Index)); | |||
3506 | OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n"; | |||
3507 | } | |||
3508 | } | |||
3509 | ||||
3510 | if (V.empty()) | |||
3511 | OS << "There are no section groups in this file.\n"; | |||
3512 | } | |||
3513 | ||||
3514 | template <class ELFT> | |||
3515 | void GNUELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) { | |||
3516 | OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n"; | |||
3517 | } | |||
3518 | ||||
3519 | template <class ELFT> | |||
3520 | void GNUELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R, | |||
3521 | const RelSymbol<ELFT> &RelSym) { | |||
3522 | // First two fields are bit width dependent. The rest of them are fixed width. | |||
3523 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3524 | Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; | |||
3525 | unsigned Width = ELFT::Is64Bits ? 16 : 8; | |||
3526 | ||||
3527 | Fields[0].Str = to_string(format_hex_no_prefix(R.Offset, Width)); | |||
3528 | Fields[1].Str = to_string(format_hex_no_prefix(R.Info, Width)); | |||
3529 | ||||
3530 | SmallString<32> RelocName; | |||
3531 | this->Obj.getRelocationTypeName(R.Type, RelocName); | |||
3532 | Fields[2].Str = RelocName.c_str(); | |||
3533 | ||||
3534 | if (RelSym.Sym) | |||
3535 | Fields[3].Str = | |||
3536 | to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width)); | |||
3537 | ||||
3538 | Fields[4].Str = std::string(RelSym.Name); | |||
3539 | for (const Field &F : Fields) | |||
3540 | printField(F); | |||
3541 | ||||
3542 | std::string Addend; | |||
3543 | if (Optional<int64_t> A = R.Addend) { | |||
3544 | int64_t RelAddend = *A; | |||
3545 | if (!RelSym.Name.empty()) { | |||
3546 | if (RelAddend < 0) { | |||
3547 | Addend = " - "; | |||
3548 | RelAddend = std::abs(RelAddend); | |||
3549 | } else { | |||
3550 | Addend = " + "; | |||
3551 | } | |||
3552 | } | |||
3553 | Addend += utohexstr(RelAddend, /*LowerCase=*/true); | |||
3554 | } | |||
3555 | OS << Addend << "\n"; | |||
3556 | } | |||
3557 | ||||
3558 | template <class ELFT> | |||
3559 | static void printRelocHeaderFields(formatted_raw_ostream &OS, unsigned SType) { | |||
3560 | bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA; | |||
3561 | bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR; | |||
3562 | if (ELFT::Is64Bits) | |||
3563 | OS << " "; | |||
3564 | else | |||
3565 | OS << " "; | |||
3566 | if (IsRelr && opts::RawRelr) | |||
3567 | OS << "Data "; | |||
3568 | else | |||
3569 | OS << "Offset"; | |||
3570 | if (ELFT::Is64Bits) | |||
3571 | OS << " Info Type" | |||
3572 | << " Symbol's Value Symbol's Name"; | |||
3573 | else | |||
3574 | OS << " Info Type Sym. Value Symbol's Name"; | |||
3575 | if (IsRela) | |||
3576 | OS << " + Addend"; | |||
3577 | OS << "\n"; | |||
3578 | } | |||
3579 | ||||
3580 | template <class ELFT> | |||
3581 | void GNUELFDumper<ELFT>::printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
3582 | const DynRegionInfo &Reg) { | |||
3583 | uint64_t Offset = Reg.Addr - this->Obj.base(); | |||
3584 | OS << "\n'" << Name.str().c_str() << "' relocation section at offset 0x" | |||
3585 | << utohexstr(Offset, /*LowerCase=*/true) << " contains " << Reg.Size << " bytes:\n"; | |||
3586 | printRelocHeaderFields<ELFT>(OS, Type); | |||
3587 | } | |||
3588 | ||||
3589 | template <class ELFT> | |||
3590 | static bool isRelocationSec(const typename ELFT::Shdr &Sec) { | |||
3591 | return Sec.sh_type == ELF::SHT_REL || Sec.sh_type == ELF::SHT_RELA || | |||
3592 | Sec.sh_type == ELF::SHT_RELR || Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3593 | Sec.sh_type == ELF::SHT_ANDROID_RELA || | |||
3594 | Sec.sh_type == ELF::SHT_ANDROID_RELR; | |||
3595 | } | |||
3596 | ||||
3597 | template <class ELFT> void GNUELFDumper<ELFT>::printRelocations() { | |||
3598 | auto GetEntriesNum = [&](const Elf_Shdr &Sec) -> Expected<size_t> { | |||
3599 | // Android's packed relocation section needs to be unpacked first | |||
3600 | // to get the actual number of entries. | |||
3601 | if (Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3602 | Sec.sh_type == ELF::SHT_ANDROID_RELA) { | |||
3603 | Expected<std::vector<typename ELFT::Rela>> RelasOrErr = | |||
3604 | this->Obj.android_relas(Sec); | |||
3605 | if (!RelasOrErr) | |||
3606 | return RelasOrErr.takeError(); | |||
3607 | return RelasOrErr->size(); | |||
3608 | } | |||
3609 | ||||
3610 | if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR || | |||
3611 | Sec.sh_type == ELF::SHT_ANDROID_RELR)) { | |||
3612 | Expected<Elf_Relr_Range> RelrsOrErr = this->Obj.relrs(Sec); | |||
3613 | if (!RelrsOrErr) | |||
3614 | return RelrsOrErr.takeError(); | |||
3615 | return this->Obj.decode_relrs(*RelrsOrErr).size(); | |||
3616 | } | |||
3617 | ||||
3618 | return Sec.getEntityCount(); | |||
3619 | }; | |||
3620 | ||||
3621 | bool HasRelocSections = false; | |||
3622 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
3623 | if (!isRelocationSec<ELFT>(Sec)) | |||
3624 | continue; | |||
3625 | HasRelocSections = true; | |||
3626 | ||||
3627 | std::string EntriesNum = "<?>"; | |||
3628 | if (Expected<size_t> NumOrErr = GetEntriesNum(Sec)) | |||
3629 | EntriesNum = std::to_string(*NumOrErr); | |||
3630 | else | |||
3631 | this->reportUniqueWarning("unable to get the number of relocations in " + | |||
3632 | this->describe(Sec) + ": " + | |||
3633 | toString(NumOrErr.takeError())); | |||
3634 | ||||
3635 | uintX_t Offset = Sec.sh_offset; | |||
3636 | StringRef Name = this->getPrintableSectionName(Sec); | |||
3637 | OS << "\nRelocation section '" << Name << "' at offset 0x" | |||
3638 | << utohexstr(Offset, /*LowerCase=*/true) << " contains " << EntriesNum | |||
3639 | << " entries:\n"; | |||
3640 | printRelocHeaderFields<ELFT>(OS, Sec.sh_type); | |||
3641 | this->printRelocationsHelper(Sec); | |||
3642 | } | |||
3643 | if (!HasRelocSections) | |||
3644 | OS << "\nThere are no relocations in this file.\n"; | |||
3645 | } | |||
3646 | ||||
3647 | // Print the offset of a particular section from anyone of the ranges: | |||
3648 | // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER]. | |||
3649 | // If 'Type' does not fall within any of those ranges, then a string is | |||
3650 | // returned as '<unknown>' followed by the type value. | |||
3651 | static std::string getSectionTypeOffsetString(unsigned Type) { | |||
3652 | if (Type >= SHT_LOOS && Type <= SHT_HIOS) | |||
3653 | return "LOOS+0x" + utohexstr(Type - SHT_LOOS); | |||
3654 | else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC) | |||
3655 | return "LOPROC+0x" + utohexstr(Type - SHT_LOPROC); | |||
3656 | else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER) | |||
3657 | return "LOUSER+0x" + utohexstr(Type - SHT_LOUSER); | |||
3658 | return "0x" + utohexstr(Type) + ": <unknown>"; | |||
3659 | } | |||
3660 | ||||
3661 | static std::string getSectionTypeString(unsigned Machine, unsigned Type) { | |||
3662 | StringRef Name = getELFSectionTypeName(Machine, Type); | |||
3663 | ||||
3664 | // Handle SHT_GNU_* type names. | |||
3665 | if (Name.consume_front("SHT_GNU_")) { | |||
3666 | if (Name == "HASH") | |||
3667 | return "GNU_HASH"; | |||
3668 | // E.g. SHT_GNU_verneed -> VERNEED. | |||
3669 | return Name.upper(); | |||
3670 | } | |||
3671 | ||||
3672 | if (Name == "SHT_SYMTAB_SHNDX") | |||
3673 | return "SYMTAB SECTION INDICES"; | |||
3674 | ||||
3675 | if (Name.consume_front("SHT_")) | |||
3676 | return Name.str(); | |||
3677 | return getSectionTypeOffsetString(Type); | |||
3678 | } | |||
3679 | ||||
3680 | static void printSectionDescription(formatted_raw_ostream &OS, | |||
3681 | unsigned EMachine) { | |||
3682 | OS << "Key to Flags:\n"; | |||
3683 | OS << " W (write), A (alloc), X (execute), M (merge), S (strings), I " | |||
3684 | "(info),\n"; | |||
3685 | OS << " L (link order), O (extra OS processing required), G (group), T " | |||
3686 | "(TLS),\n"; | |||
3687 | OS << " C (compressed), x (unknown), o (OS specific), E (exclude),\n"; | |||
3688 | OS << " R (retain)"; | |||
3689 | ||||
3690 | if (EMachine == EM_X86_64) | |||
3691 | OS << ", l (large)"; | |||
3692 | else if (EMachine == EM_ARM) | |||
3693 | OS << ", y (purecode)"; | |||
3694 | ||||
3695 | OS << ", p (processor specific)\n"; | |||
3696 | } | |||
3697 | ||||
3698 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionHeaders() { | |||
3699 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
3700 | if (Sections.empty()) { | |||
3701 | OS << "\nThere are no sections in this file.\n"; | |||
3702 | Expected<StringRef> SecStrTableOrErr = | |||
3703 | this->Obj.getSectionStringTable(Sections, this->WarningHandler); | |||
3704 | if (!SecStrTableOrErr) | |||
3705 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
3706 | return; | |||
3707 | } | |||
3708 | unsigned Bias = ELFT::Is64Bits ? 0 : 8; | |||
3709 | OS << "There are " << to_string(Sections.size()) | |||
3710 | << " section headers, starting at offset " | |||
3711 | << "0x" << utohexstr(this->Obj.getHeader().e_shoff, /*LowerCase=*/true) << ":\n\n"; | |||
3712 | OS << "Section Headers:\n"; | |||
3713 | Field Fields[11] = { | |||
3714 | {"[Nr]", 2}, {"Name", 7}, {"Type", 25}, | |||
3715 | {"Address", 41}, {"Off", 58 - Bias}, {"Size", 65 - Bias}, | |||
3716 | {"ES", 72 - Bias}, {"Flg", 75 - Bias}, {"Lk", 79 - Bias}, | |||
3717 | {"Inf", 82 - Bias}, {"Al", 86 - Bias}}; | |||
3718 | for (const Field &F : Fields) | |||
3719 | printField(F); | |||
3720 | OS << "\n"; | |||
3721 | ||||
3722 | StringRef SecStrTable; | |||
3723 | if (Expected<StringRef> SecStrTableOrErr = | |||
3724 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
3725 | SecStrTable = *SecStrTableOrErr; | |||
3726 | else | |||
3727 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
3728 | ||||
3729 | size_t SectionIndex = 0; | |||
3730 | for (const Elf_Shdr &Sec : Sections) { | |||
3731 | Fields[0].Str = to_string(SectionIndex); | |||
3732 | if (SecStrTable.empty()) | |||
3733 | Fields[1].Str = "<no-strings>"; | |||
3734 | else | |||
3735 | Fields[1].Str = std::string(unwrapOrError<StringRef>( | |||
3736 | this->FileName, this->Obj.getSectionName(Sec, SecStrTable))); | |||
3737 | Fields[2].Str = | |||
3738 | getSectionTypeString(this->Obj.getHeader().e_machine, Sec.sh_type); | |||
3739 | Fields[3].Str = | |||
3740 | to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8)); | |||
3741 | Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); | |||
3742 | Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6)); | |||
3743 | Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); | |||
3744 | Fields[7].Str = getGNUFlags(this->Obj.getHeader().e_ident[ELF::EI_OSABI], | |||
3745 | this->Obj.getHeader().e_machine, Sec.sh_flags); | |||
3746 | Fields[8].Str = to_string(Sec.sh_link); | |||
3747 | Fields[9].Str = to_string(Sec.sh_info); | |||
3748 | Fields[10].Str = to_string(Sec.sh_addralign); | |||
3749 | ||||
3750 | OS.PadToColumn(Fields[0].Column); | |||
3751 | OS << "[" << right_justify(Fields[0].Str, 2) << "]"; | |||
3752 | for (int i = 1; i < 7; i++) | |||
3753 | printField(Fields[i]); | |||
3754 | OS.PadToColumn(Fields[7].Column); | |||
3755 | OS << right_justify(Fields[7].Str, 3); | |||
3756 | OS.PadToColumn(Fields[8].Column); | |||
3757 | OS << right_justify(Fields[8].Str, 2); | |||
3758 | OS.PadToColumn(Fields[9].Column); | |||
3759 | OS << right_justify(Fields[9].Str, 3); | |||
3760 | OS.PadToColumn(Fields[10].Column); | |||
3761 | OS << right_justify(Fields[10].Str, 2); | |||
3762 | OS << "\n"; | |||
3763 | ++SectionIndex; | |||
3764 | } | |||
3765 | printSectionDescription(OS, this->Obj.getHeader().e_machine); | |||
3766 | } | |||
3767 | ||||
3768 | template <class ELFT> | |||
3769 | void GNUELFDumper<ELFT>::printSymtabMessage(const Elf_Shdr *Symtab, | |||
3770 | size_t Entries, | |||
3771 | bool NonVisibilityBitsUsed) const { | |||
3772 | StringRef Name; | |||
3773 | if (Symtab) | |||
3774 | Name = this->getPrintableSectionName(*Symtab); | |||
3775 | if (!Name.empty()) | |||
3776 | OS << "\nSymbol table '" << Name << "'"; | |||
3777 | else | |||
3778 | OS << "\nSymbol table for image"; | |||
3779 | OS << " contains " << Entries << " entries:\n"; | |||
3780 | ||||
3781 | if (ELFT::Is64Bits) | |||
3782 | OS << " Num: Value Size Type Bind Vis"; | |||
3783 | else | |||
3784 | OS << " Num: Value Size Type Bind Vis"; | |||
3785 | ||||
3786 | if (NonVisibilityBitsUsed) | |||
3787 | OS << " "; | |||
3788 | OS << " Ndx Name\n"; | |||
3789 | } | |||
3790 | ||||
3791 | template <class ELFT> | |||
3792 | std::string | |||
3793 | GNUELFDumper<ELFT>::getSymbolSectionNdx(const Elf_Sym &Symbol, | |||
3794 | unsigned SymIndex, | |||
3795 | DataRegion<Elf_Word> ShndxTable) const { | |||
3796 | unsigned SectionIndex = Symbol.st_shndx; | |||
3797 | switch (SectionIndex) { | |||
3798 | case ELF::SHN_UNDEF: | |||
3799 | return "UND"; | |||
3800 | case ELF::SHN_ABS: | |||
3801 | return "ABS"; | |||
3802 | case ELF::SHN_COMMON: | |||
3803 | return "COM"; | |||
3804 | case ELF::SHN_XINDEX: { | |||
3805 | Expected<uint32_t> IndexOrErr = | |||
3806 | object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, ShndxTable); | |||
3807 | if (!IndexOrErr) { | |||
3808 | 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", 3810, __extension__ __PRETTY_FUNCTION__)) | |||
3809 | "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", 3810, __extension__ __PRETTY_FUNCTION__)) | |||
3810 | "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", 3810, __extension__ __PRETTY_FUNCTION__)); | |||
3811 | this->reportUniqueWarning(IndexOrErr.takeError()); | |||
3812 | return "RSV[0xffff]"; | |||
3813 | } | |||
3814 | return to_string(format_decimal(*IndexOrErr, 3)); | |||
3815 | } | |||
3816 | default: | |||
3817 | // Find if: | |||
3818 | // Processor specific | |||
3819 | if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) | |||
3820 | return std::string("PRC[0x") + | |||
3821 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3822 | // OS specific | |||
3823 | if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) | |||
3824 | return std::string("OS[0x") + | |||
3825 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3826 | // Architecture reserved: | |||
3827 | if (SectionIndex >= ELF::SHN_LORESERVE && | |||
3828 | SectionIndex <= ELF::SHN_HIRESERVE) | |||
3829 | return std::string("RSV[0x") + | |||
3830 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
3831 | // A normal section with an index | |||
3832 | return to_string(format_decimal(SectionIndex, 3)); | |||
3833 | } | |||
3834 | } | |||
3835 | ||||
3836 | template <class ELFT> | |||
3837 | void GNUELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
3838 | DataRegion<Elf_Word> ShndxTable, | |||
3839 | Optional<StringRef> StrTable, | |||
3840 | bool IsDynamic, | |||
3841 | bool NonVisibilityBitsUsed) const { | |||
3842 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3843 | Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, | |||
3844 | 31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias}; | |||
3845 | Fields[0].Str = to_string(format_decimal(SymIndex, 6)) + ":"; | |||
3846 | Fields[1].Str = | |||
3847 | to_string(format_hex_no_prefix(Symbol.st_value, ELFT::Is64Bits ? 16 : 8)); | |||
3848 | Fields[2].Str = to_string(format_decimal(Symbol.st_size, 5)); | |||
3849 | ||||
3850 | unsigned char SymbolType = Symbol.getType(); | |||
3851 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
3852 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
3853 | Fields[3].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); | |||
3854 | else | |||
3855 | Fields[3].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); | |||
3856 | ||||
3857 | Fields[4].Str = | |||
3858 | enumToString(Symbol.getBinding(), makeArrayRef(ElfSymbolBindings)); | |||
3859 | Fields[5].Str = | |||
3860 | enumToString(Symbol.getVisibility(), makeArrayRef(ElfSymbolVisibilities)); | |||
3861 | ||||
3862 | if (Symbol.st_other & ~0x3) { | |||
3863 | if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) { | |||
3864 | uint8_t Other = Symbol.st_other & ~0x3; | |||
3865 | if (Other & STO_AARCH64_VARIANT_PCS) { | |||
3866 | Other &= ~STO_AARCH64_VARIANT_PCS; | |||
3867 | Fields[5].Str += " [VARIANT_PCS"; | |||
3868 | if (Other != 0) | |||
3869 | Fields[5].Str.append(" | " + utohexstr(Other, /*LowerCase=*/true)); | |||
3870 | Fields[5].Str.append("]"); | |||
3871 | } | |||
3872 | } else if (this->Obj.getHeader().e_machine == ELF::EM_RISCV) { | |||
3873 | uint8_t Other = Symbol.st_other & ~0x3; | |||
3874 | if (Other & STO_RISCV_VARIANT_CC) { | |||
3875 | Other &= ~STO_RISCV_VARIANT_CC; | |||
3876 | Fields[5].Str += " [VARIANT_CC"; | |||
3877 | if (Other != 0) | |||
3878 | Fields[5].Str.append(" | " + utohexstr(Other, /*LowerCase=*/true)); | |||
3879 | Fields[5].Str.append("]"); | |||
3880 | } | |||
3881 | } else { | |||
3882 | Fields[5].Str += | |||
3883 | " [<other: " + to_string(format_hex(Symbol.st_other, 2)) + ">]"; | |||
3884 | } | |||
3885 | } | |||
3886 | ||||
3887 | Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0; | |||
3888 | Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex, ShndxTable); | |||
3889 | ||||
3890 | Fields[7].Str = this->getFullSymbolName(Symbol, SymIndex, ShndxTable, | |||
3891 | StrTable, IsDynamic); | |||
3892 | for (const Field &Entry : Fields) | |||
3893 | printField(Entry); | |||
3894 | OS << "\n"; | |||
3895 | } | |||
3896 | ||||
3897 | template <class ELFT> | |||
3898 | void GNUELFDumper<ELFT>::printHashedSymbol(const Elf_Sym *Symbol, | |||
3899 | unsigned SymIndex, | |||
3900 | DataRegion<Elf_Word> ShndxTable, | |||
3901 | StringRef StrTable, | |||
3902 | uint32_t Bucket) { | |||
3903 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3904 | Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias, | |||
3905 | 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias}; | |||
3906 | Fields[0].Str = to_string(format_decimal(SymIndex, 5)); | |||
3907 | Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":"; | |||
3908 | ||||
3909 | Fields[2].Str = to_string( | |||
3910 | format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); | |||
3911 | Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5)); | |||
3912 | ||||
3913 | unsigned char SymbolType = Symbol->getType(); | |||
3914 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
3915 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
3916 | Fields[4].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); | |||
3917 | else | |||
3918 | Fields[4].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); | |||
3919 | ||||
3920 | Fields[5].Str = | |||
3921 | enumToString(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); | |||
3922 | Fields[6].Str = enumToString(Symbol->getVisibility(), | |||
3923 | makeArrayRef(ElfSymbolVisibilities)); | |||
3924 | Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable); | |||
3925 | Fields[8].Str = | |||
3926 | this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true); | |||
3927 | ||||
3928 | for (const Field &Entry : Fields) | |||
3929 | printField(Entry); | |||
3930 | OS << "\n"; | |||
3931 | } | |||
3932 | ||||
3933 | template <class ELFT> | |||
3934 | void GNUELFDumper<ELFT>::printSymbols(bool PrintSymbols, | |||
3935 | bool PrintDynamicSymbols) { | |||
3936 | if (!PrintSymbols && !PrintDynamicSymbols) | |||
3937 | return; | |||
3938 | // GNU readelf prints both the .dynsym and .symtab with --symbols. | |||
3939 | this->printSymbolsHelper(true); | |||
3940 | if (PrintSymbols) | |||
3941 | this->printSymbolsHelper(false); | |||
3942 | } | |||
3943 | ||||
3944 | template <class ELFT> | |||
3945 | void GNUELFDumper<ELFT>::printHashTableSymbols(const Elf_Hash &SysVHash) { | |||
3946 | if (this->DynamicStringTable.empty()) | |||
3947 | return; | |||
3948 | ||||
3949 | if (ELFT::Is64Bits) | |||
3950 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
3951 | else | |||
3952 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
3953 | OS << "\n"; | |||
3954 | ||||
3955 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
3956 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
3957 | if (!FirstSym) { | |||
3958 | this->reportUniqueWarning( | |||
3959 | Twine("unable to print symbols for the .hash table: the " | |||
3960 | "dynamic symbol table ") + | |||
3961 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
3962 | return; | |||
3963 | } | |||
3964 | ||||
3965 | DataRegion<Elf_Word> ShndxTable( | |||
3966 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
3967 | auto Buckets = SysVHash.buckets(); | |||
3968 | auto Chains = SysVHash.chains(); | |||
3969 | for (uint32_t Buc = 0; Buc < SysVHash.nbucket; Buc++) { | |||
3970 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
3971 | continue; | |||
3972 | BitVector Visited(SysVHash.nchain); | |||
3973 | for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash.nchain; Ch = Chains[Ch]) { | |||
3974 | if (Ch == ELF::STN_UNDEF) | |||
3975 | break; | |||
3976 | ||||
3977 | if (Visited[Ch]) { | |||
3978 | this->reportUniqueWarning(".hash section is invalid: bucket " + | |||
3979 | Twine(Ch) + | |||
3980 | ": a cycle was detected in the linked chain"); | |||
3981 | break; | |||
3982 | } | |||
3983 | ||||
3984 | printHashedSymbol(FirstSym + Ch, Ch, ShndxTable, this->DynamicStringTable, | |||
3985 | Buc); | |||
3986 | Visited[Ch] = true; | |||
3987 | } | |||
3988 | } | |||
3989 | } | |||
3990 | ||||
3991 | template <class ELFT> | |||
3992 | void GNUELFDumper<ELFT>::printGnuHashTableSymbols(const Elf_GnuHash &GnuHash) { | |||
3993 | if (this->DynamicStringTable.empty()) | |||
3994 | return; | |||
3995 | ||||
3996 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
3997 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
3998 | if (!FirstSym) { | |||
3999 | this->reportUniqueWarning( | |||
4000 | Twine("unable to print symbols for the .gnu.hash table: the " | |||
4001 | "dynamic symbol table ") + | |||
4002 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
4003 | return; | |||
4004 | } | |||
4005 | ||||
4006 | auto GetSymbol = [&](uint64_t SymIndex, | |||
4007 | uint64_t SymsTotal) -> const Elf_Sym * { | |||
4008 | if (SymIndex >= SymsTotal) { | |||
4009 | this->reportUniqueWarning( | |||
4010 | "unable to print hashed symbol with index " + Twine(SymIndex) + | |||
4011 | ", which is greater than or equal to the number of dynamic symbols " | |||
4012 | "(" + | |||
4013 | Twine::utohexstr(SymsTotal) + ")"); | |||
4014 | return nullptr; | |||
4015 | } | |||
4016 | return FirstSym + SymIndex; | |||
4017 | }; | |||
4018 | ||||
4019 | Expected<ArrayRef<Elf_Word>> ValuesOrErr = | |||
4020 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHash); | |||
4021 | ArrayRef<Elf_Word> Values; | |||
4022 | if (!ValuesOrErr) | |||
4023 | this->reportUniqueWarning("unable to get hash values for the SHT_GNU_HASH " | |||
4024 | "section: " + | |||
4025 | toString(ValuesOrErr.takeError())); | |||
4026 | else | |||
4027 | Values = *ValuesOrErr; | |||
4028 | ||||
4029 | DataRegion<Elf_Word> ShndxTable( | |||
4030 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
4031 | ArrayRef<Elf_Word> Buckets = GnuHash.buckets(); | |||
4032 | for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) { | |||
4033 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
4034 | continue; | |||
4035 | uint32_t Index = Buckets[Buc]; | |||
4036 | // Print whole chain. | |||
4037 | while (true) { | |||
4038 | uint32_t SymIndex = Index++; | |||
4039 | if (const Elf_Sym *Sym = GetSymbol(SymIndex, DynSyms.size())) | |||
4040 | printHashedSymbol(Sym, SymIndex, ShndxTable, this->DynamicStringTable, | |||
4041 | Buc); | |||
4042 | else | |||
4043 | break; | |||
4044 | ||||
4045 | if (SymIndex < GnuHash.symndx) { | |||
4046 | this->reportUniqueWarning( | |||
4047 | "unable to read the hash value for symbol with index " + | |||
4048 | Twine(SymIndex) + | |||
4049 | ", which is less than the index of the first hashed symbol (" + | |||
4050 | Twine(GnuHash.symndx) + ")"); | |||
4051 | break; | |||
4052 | } | |||
4053 | ||||
4054 | // Chain ends at symbol with stopper bit. | |||
4055 | if ((Values[SymIndex - GnuHash.symndx] & 1) == 1) | |||
4056 | break; | |||
4057 | } | |||
4058 | } | |||
4059 | } | |||
4060 | ||||
4061 | template <class ELFT> void GNUELFDumper<ELFT>::printHashSymbols() { | |||
4062 | if (this->HashTable) { | |||
4063 | OS << "\n Symbol table of .hash for image:\n"; | |||
4064 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
4065 | this->reportUniqueWarning(std::move(E)); | |||
4066 | else | |||
4067 | printHashTableSymbols(*this->HashTable); | |||
4068 | } | |||
4069 | ||||
4070 | // Try printing the .gnu.hash table. | |||
4071 | if (this->GnuHashTable) { | |||
4072 | OS << "\n Symbol table of .gnu.hash for image:\n"; | |||
4073 | if (ELFT::Is64Bits) | |||
4074 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4075 | else | |||
4076 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4077 | OS << "\n"; | |||
4078 | ||||
4079 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
4080 | this->reportUniqueWarning(std::move(E)); | |||
4081 | else | |||
4082 | printGnuHashTableSymbols(*this->GnuHashTable); | |||
4083 | } | |||
4084 | } | |||
4085 | ||||
4086 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionDetails() { | |||
4087 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
4088 | if (Sections.empty()) { | |||
4089 | OS << "\nThere are no sections in this file.\n"; | |||
4090 | Expected<StringRef> SecStrTableOrErr = | |||
4091 | this->Obj.getSectionStringTable(Sections, this->WarningHandler); | |||
4092 | if (!SecStrTableOrErr) | |||
4093 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
4094 | return; | |||
4095 | } | |||
4096 | OS << "There are " << to_string(Sections.size()) | |||
4097 | << " section headers, starting at offset " | |||
4098 | << "0x" << utohexstr(this->Obj.getHeader().e_shoff, /*LowerCase=*/true) << ":\n\n"; | |||
4099 | ||||
4100 | OS << "Section Headers:\n"; | |||
4101 | ||||
4102 | auto PrintFields = [&](ArrayRef<Field> V) { | |||
4103 | for (const Field &F : V) | |||
4104 | printField(F); | |||
4105 | OS << "\n"; | |||
4106 | }; | |||
4107 | ||||
4108 | PrintFields({{"[Nr]", 2}, {"Name", 7}}); | |||
4109 | ||||
4110 | constexpr bool Is64 = ELFT::Is64Bits; | |||
4111 | PrintFields({{"Type", 7}, | |||
4112 | {Is64 ? "Address" : "Addr", 23}, | |||
4113 | {"Off", Is64 ? 40 : 32}, | |||
4114 | {"Size", Is64 ? 47 : 39}, | |||
4115 | {"ES", Is64 ? 54 : 46}, | |||
4116 | {"Lk", Is64 ? 59 : 51}, | |||
4117 | {"Inf", Is64 ? 62 : 54}, | |||
4118 | {"Al", Is64 ? 66 : 57}}); | |||
4119 | PrintFields({{"Flags", 7}}); | |||
4120 | ||||
4121 | StringRef SecStrTable; | |||
4122 | if (Expected<StringRef> SecStrTableOrErr = | |||
4123 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
4124 | SecStrTable = *SecStrTableOrErr; | |||
4125 | else | |||
4126 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
4127 | ||||
4128 | size_t SectionIndex = 0; | |||
4129 | const unsigned AddrSize = Is64 ? 16 : 8; | |||
4130 | for (const Elf_Shdr &S : Sections) { | |||
4131 | StringRef Name = "<?>"; | |||
4132 | if (Expected<StringRef> NameOrErr = | |||
4133 | this->Obj.getSectionName(S, SecStrTable)) | |||
4134 | Name = *NameOrErr; | |||
4135 | else | |||
4136 | this->reportUniqueWarning(NameOrErr.takeError()); | |||
4137 | ||||
4138 | OS.PadToColumn(2); | |||
4139 | OS << "[" << right_justify(to_string(SectionIndex), 2) << "]"; | |||
4140 | PrintFields({{Name, 7}}); | |||
4141 | PrintFields( | |||
4142 | {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type), 7}, | |||
4143 | {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 23}, | |||
4144 | {to_string(format_hex_no_prefix(S.sh_offset, 6)), Is64 ? 39 : 32}, | |||
4145 | {to_string(format_hex_no_prefix(S.sh_size, 6)), Is64 ? 47 : 39}, | |||
4146 | {to_string(format_hex_no_prefix(S.sh_entsize, 2)), Is64 ? 54 : 46}, | |||
4147 | {to_string(S.sh_link), Is64 ? 59 : 51}, | |||
4148 | {to_string(S.sh_info), Is64 ? 63 : 55}, | |||
4149 | {to_string(S.sh_addralign), Is64 ? 66 : 58}}); | |||
4150 | ||||
4151 | OS.PadToColumn(7); | |||
4152 | OS << "[" << to_string(format_hex_no_prefix(S.sh_flags, AddrSize)) << "]: "; | |||
4153 | ||||
4154 | DenseMap<unsigned, StringRef> FlagToName = { | |||
4155 | {SHF_WRITE, "WRITE"}, {SHF_ALLOC, "ALLOC"}, | |||
4156 | {SHF_EXECINSTR, "EXEC"}, {SHF_MERGE, "MERGE"}, | |||
4157 | {SHF_STRINGS, "STRINGS"}, {SHF_INFO_LINK, "INFO LINK"}, | |||
4158 | {SHF_LINK_ORDER, "LINK ORDER"}, {SHF_OS_NONCONFORMING, "OS NONCONF"}, | |||
4159 | {SHF_GROUP, "GROUP"}, {SHF_TLS, "TLS"}, | |||
4160 | {SHF_COMPRESSED, "COMPRESSED"}, {SHF_EXCLUDE, "EXCLUDE"}}; | |||
4161 | ||||
4162 | uint64_t Flags = S.sh_flags; | |||
4163 | uint64_t UnknownFlags = 0; | |||
4164 | ListSeparator LS; | |||
4165 | while (Flags) { | |||
4166 | // Take the least significant bit as a flag. | |||
4167 | uint64_t Flag = Flags & -Flags; | |||
4168 | Flags -= Flag; | |||
4169 | ||||
4170 | auto It = FlagToName.find(Flag); | |||
4171 | if (It != FlagToName.end()) | |||
4172 | OS << LS << It->second; | |||
4173 | else | |||
4174 | UnknownFlags |= Flag; | |||
4175 | } | |||
4176 | ||||
4177 | auto PrintUnknownFlags = [&](uint64_t Mask, StringRef Name) { | |||
4178 | uint64_t FlagsToPrint = UnknownFlags & Mask; | |||
4179 | if (!FlagsToPrint) | |||
4180 | return; | |||
4181 | ||||
4182 | OS << LS << Name << " (" | |||
4183 | << to_string(format_hex_no_prefix(FlagsToPrint, AddrSize)) << ")"; | |||
4184 | UnknownFlags &= ~Mask; | |||
4185 | }; | |||
4186 | ||||
4187 | PrintUnknownFlags(SHF_MASKOS, "OS"); | |||
4188 | PrintUnknownFlags(SHF_MASKPROC, "PROC"); | |||
4189 | PrintUnknownFlags(uint64_t(-1), "UNKNOWN"); | |||
4190 | ||||
4191 | OS << "\n"; | |||
4192 | ++SectionIndex; | |||
4193 | ||||
4194 | if (!(S.sh_flags & SHF_COMPRESSED)) | |||
4195 | continue; | |||
4196 | Expected<ArrayRef<uint8_t>> Data = this->Obj.getSectionContents(S); | |||
4197 | if (!Data || Data->size() < sizeof(Elf_Chdr)) { | |||
4198 | consumeError(Data.takeError()); | |||
4199 | reportWarning(createError("SHF_COMPRESSED section '" + Name + | |||
4200 | "' does not have an Elf_Chdr header"), | |||
4201 | this->FileName); | |||
4202 | OS.indent(7); | |||
4203 | OS << "[<corrupt>]"; | |||
4204 | } else { | |||
4205 | OS.indent(7); | |||
4206 | auto *Chdr = reinterpret_cast<const Elf_Chdr *>(Data->data()); | |||
4207 | if (Chdr->ch_type == ELFCOMPRESS_ZLIB) | |||
4208 | OS << "ZLIB"; | |||
4209 | else if (Chdr->ch_type == ELFCOMPRESS_ZSTD) | |||
4210 | OS << "ZSTD"; | |||
4211 | else | |||
4212 | OS << format("[<unknown>: 0x%x]", unsigned(Chdr->ch_type)); | |||
4213 | OS << ", " << format_hex_no_prefix(Chdr->ch_size, ELFT::Is64Bits ? 16 : 8) | |||
4214 | << ", " << Chdr->ch_addralign; | |||
4215 | } | |||
4216 | OS << '\n'; | |||
4217 | } | |||
4218 | } | |||
4219 | ||||
4220 | static inline std::string printPhdrFlags(unsigned Flag) { | |||
4221 | std::string Str; | |||
4222 | Str = (Flag & PF_R) ? "R" : " "; | |||
4223 | Str += (Flag & PF_W) ? "W" : " "; | |||
4224 | Str += (Flag & PF_X) ? "E" : " "; | |||
4225 | return Str; | |||
4226 | } | |||
4227 | ||||
4228 | template <class ELFT> | |||
4229 | static bool checkTLSSections(const typename ELFT::Phdr &Phdr, | |||
4230 | const typename ELFT::Shdr &Sec) { | |||
4231 | if (Sec.sh_flags & ELF::SHF_TLS) { | |||
4232 | // .tbss must only be shown in the PT_TLS segment. | |||
4233 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4234 | return Phdr.p_type == ELF::PT_TLS; | |||
4235 | ||||
4236 | // SHF_TLS sections are only shown in PT_TLS, PT_LOAD or PT_GNU_RELRO | |||
4237 | // segments. | |||
4238 | return (Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || | |||
4239 | (Phdr.p_type == ELF::PT_GNU_RELRO); | |||
4240 | } | |||
4241 | ||||
4242 | // PT_TLS must only have SHF_TLS sections. | |||
4243 | return Phdr.p_type != ELF::PT_TLS; | |||
4244 | } | |||
4245 | ||||
4246 | template <class ELFT> | |||
4247 | static bool checkOffsets(const typename ELFT::Phdr &Phdr, | |||
4248 | const typename ELFT::Shdr &Sec) { | |||
4249 | // SHT_NOBITS sections don't need to have an offset inside the segment. | |||
4250 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4251 | return true; | |||
4252 | ||||
4253 | if (Sec.sh_offset < Phdr.p_offset) | |||
4254 | return false; | |||
4255 | ||||
4256 | // Only non-empty sections can be at the end of a segment. | |||
4257 | if (Sec.sh_size == 0) | |||
4258 | return (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz); | |||
4259 | return Sec.sh_offset + Sec.sh_size <= Phdr.p_offset + Phdr.p_filesz; | |||
4260 | } | |||
4261 | ||||
4262 | // Check that an allocatable section belongs to a virtual address | |||
4263 | // space of a segment. | |||
4264 | template <class ELFT> | |||
4265 | static bool checkVMA(const typename ELFT::Phdr &Phdr, | |||
4266 | const typename ELFT::Shdr &Sec) { | |||
4267 | if (!(Sec.sh_flags & ELF::SHF_ALLOC)) | |||
4268 | return true; | |||
4269 | ||||
4270 | if (Sec.sh_addr < Phdr.p_vaddr) | |||
4271 | return false; | |||
4272 | ||||
4273 | bool IsTbss = | |||
4274 | (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); | |||
4275 | // .tbss is special, it only has memory in PT_TLS and has NOBITS properties. | |||
4276 | bool IsTbssInNonTLS = IsTbss && Phdr.p_type != ELF::PT_TLS; | |||
4277 | // Only non-empty sections can be at the end of a segment. | |||
4278 | if (Sec.sh_size == 0 || IsTbssInNonTLS) | |||
4279 | return Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4280 | return Sec.sh_addr + Sec.sh_size <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4281 | } | |||
4282 | ||||
4283 | template <class ELFT> | |||
4284 | static bool checkPTDynamic(const typename ELFT::Phdr &Phdr, | |||
4285 | const typename ELFT::Shdr &Sec) { | |||
4286 | if (Phdr.p_type != ELF::PT_DYNAMIC || Phdr.p_memsz == 0 || Sec.sh_size != 0) | |||
4287 | return true; | |||
4288 | ||||
4289 | // We get here when we have an empty section. Only non-empty sections can be | |||
4290 | // at the start or at the end of PT_DYNAMIC. | |||
4291 | // Is section within the phdr both based on offset and VMA? | |||
4292 | bool CheckOffset = (Sec.sh_type == ELF::SHT_NOBITS) || | |||
4293 | (Sec.sh_offset > Phdr.p_offset && | |||
4294 | Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz); | |||
4295 | bool CheckVA = !(Sec.sh_flags & ELF::SHF_ALLOC) || | |||
4296 | (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz); | |||
4297 | return CheckOffset && CheckVA; | |||
4298 | } | |||
4299 | ||||
4300 | template <class ELFT> | |||
4301 | void GNUELFDumper<ELFT>::printProgramHeaders( | |||
4302 | bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { | |||
4303 | const bool ShouldPrintSectionMapping = (PrintSectionMapping != cl::BOU_FALSE); | |||
4304 | // Exit early if no program header or section mapping details were requested. | |||
4305 | if (!PrintProgramHeaders && !ShouldPrintSectionMapping) | |||
4306 | return; | |||
4307 | ||||
4308 | if (PrintProgramHeaders) { | |||
4309 | const Elf_Ehdr &Header = this->Obj.getHeader(); | |||
4310 | if (Header.e_phnum == 0) { | |||
4311 | OS << "\nThere are no program headers in this file.\n"; | |||
4312 | } else { | |||
4313 | printProgramHeaders(); | |||
4314 | } | |||
4315 | } | |||
4316 | ||||
4317 | if (ShouldPrintSectionMapping) | |||
4318 | printSectionMapping(); | |||
4319 | } | |||
4320 | ||||
4321 | template <class ELFT> void GNUELFDumper<ELFT>::printProgramHeaders() { | |||
4322 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
4323 | const Elf_Ehdr &Header = this->Obj.getHeader(); | |||
4324 | Field Fields[8] = {2, 17, 26, 37 + Bias, | |||
4325 | 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; | |||
4326 | OS << "\nElf file type is " | |||
4327 | << enumToString(Header.e_type, makeArrayRef(ElfObjectFileType)) << "\n" | |||
4328 | << "Entry point " << format_hex(Header.e_entry, 3) << "\n" | |||
4329 | << "There are " << Header.e_phnum << " program headers," | |||
4330 | << " starting at offset " << Header.e_phoff << "\n\n" | |||
4331 | << "Program Headers:\n"; | |||
4332 | if (ELFT::Is64Bits) | |||
4333 | OS << " Type Offset VirtAddr PhysAddr " | |||
4334 | << " FileSiz MemSiz Flg Align\n"; | |||
4335 | else | |||
4336 | OS << " Type Offset VirtAddr PhysAddr FileSiz " | |||
4337 | << "MemSiz Flg Align\n"; | |||
4338 | ||||
4339 | unsigned Width = ELFT::Is64Bits ? 18 : 10; | |||
4340 | unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; | |||
4341 | ||||
4342 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4343 | if (!PhdrsOrErr) { | |||
4344 | this->reportUniqueWarning("unable to dump program headers: " + | |||
4345 | toString(PhdrsOrErr.takeError())); | |||
4346 | return; | |||
4347 | } | |||
4348 | ||||
4349 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4350 | Fields[0].Str = getGNUPtType(Header.e_machine, Phdr.p_type); | |||
4351 | Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8)); | |||
4352 | Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width)); | |||
4353 | Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width)); | |||
4354 | Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth)); | |||
4355 | Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth)); | |||
4356 | Fields[6].Str = printPhdrFlags(Phdr.p_flags); | |||
4357 | Fields[7].Str = to_string(format_hex(Phdr.p_align, 1)); | |||
4358 | for (const Field &F : Fields) | |||
4359 | printField(F); | |||
4360 | if (Phdr.p_type == ELF::PT_INTERP) { | |||
4361 | OS << "\n"; | |||
4362 | auto ReportBadInterp = [&](const Twine &Msg) { | |||
4363 | this->reportUniqueWarning( | |||
4364 | "unable to read program interpreter name at offset 0x" + | |||
4365 | Twine::utohexstr(Phdr.p_offset) + ": " + Msg); | |||
4366 | }; | |||
4367 | ||||
4368 | if (Phdr.p_offset >= this->Obj.getBufSize()) { | |||
4369 | ReportBadInterp("it goes past the end of the file (0x" + | |||
4370 | Twine::utohexstr(this->Obj.getBufSize()) + ")"); | |||
4371 | continue; | |||
4372 | } | |||
4373 | ||||
4374 | const char *Data = | |||
4375 | reinterpret_cast<const char *>(this->Obj.base()) + Phdr.p_offset; | |||
4376 | size_t MaxSize = this->Obj.getBufSize() - Phdr.p_offset; | |||
4377 | size_t Len = strnlen(Data, MaxSize); | |||
4378 | if (Len == MaxSize) { | |||
4379 | ReportBadInterp("it is not null-terminated"); | |||
4380 | continue; | |||
4381 | } | |||
4382 | ||||
4383 | OS << " [Requesting program interpreter: "; | |||
4384 | OS << StringRef(Data, Len) << "]"; | |||
4385 | } | |||
4386 | OS << "\n"; | |||
4387 | } | |||
4388 | } | |||
4389 | ||||
4390 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionMapping() { | |||
4391 | OS << "\n Section to Segment mapping:\n Segment Sections...\n"; | |||
4392 | DenseSet<const Elf_Shdr *> BelongsToSegment; | |||
4393 | int Phnum = 0; | |||
4394 | ||||
4395 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4396 | if (!PhdrsOrErr) { | |||
4397 | this->reportUniqueWarning( | |||
4398 | "can't read program headers to build section to segment mapping: " + | |||
4399 | toString(PhdrsOrErr.takeError())); | |||
4400 | return; | |||
4401 | } | |||
4402 | ||||
4403 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4404 | std::string Sections; | |||
4405 | OS << format(" %2.2d ", Phnum++); | |||
4406 | // Check if each section is in a segment and then print mapping. | |||
4407 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4408 | if (Sec.sh_type == ELF::SHT_NULL) | |||
4409 | continue; | |||
4410 | ||||
4411 | // readelf additionally makes sure it does not print zero sized sections | |||
4412 | // at end of segments and for PT_DYNAMIC both start and end of section | |||
4413 | // .tbss must only be shown in PT_TLS section. | |||
4414 | if (checkTLSSections<ELFT>(Phdr, Sec) && checkOffsets<ELFT>(Phdr, Sec) && | |||
4415 | checkVMA<ELFT>(Phdr, Sec) && checkPTDynamic<ELFT>(Phdr, Sec)) { | |||
4416 | Sections += | |||
4417 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4418 | " "; | |||
4419 | BelongsToSegment.insert(&Sec); | |||
4420 | } | |||
4421 | } | |||
4422 | OS << Sections << "\n"; | |||
4423 | OS.flush(); | |||
4424 | } | |||
4425 | ||||
4426 | // Display sections that do not belong to a segment. | |||
4427 | std::string Sections; | |||
4428 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4429 | if (BelongsToSegment.find(&Sec) == BelongsToSegment.end()) | |||
4430 | Sections += | |||
4431 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4432 | ' '; | |||
4433 | } | |||
4434 | if (!Sections.empty()) { | |||
4435 | OS << " None " << Sections << '\n'; | |||
4436 | OS.flush(); | |||
4437 | } | |||
4438 | } | |||
4439 | ||||
4440 | namespace { | |||
4441 | ||||
4442 | template <class ELFT> | |||
4443 | RelSymbol<ELFT> getSymbolForReloc(const ELFDumper<ELFT> &Dumper, | |||
4444 | const Relocation<ELFT> &Reloc) { | |||
4445 | using Elf_Sym = typename ELFT::Sym; | |||
4446 | auto WarnAndReturn = [&](const Elf_Sym *Sym, | |||
4447 | const Twine &Reason) -> RelSymbol<ELFT> { | |||
4448 | Dumper.reportUniqueWarning( | |||
4449 | "unable to get name of the dynamic symbol with index " + | |||
4450 | Twine(Reloc.Symbol) + ": " + Reason); | |||
4451 | return {Sym, "<corrupt>"}; | |||
4452 | }; | |||
4453 | ||||
4454 | ArrayRef<Elf_Sym> Symbols = Dumper.dynamic_symbols(); | |||
4455 | const Elf_Sym *FirstSym = Symbols.begin(); | |||
4456 | if (!FirstSym) | |||
4457 | return WarnAndReturn(nullptr, "no dynamic symbol table found"); | |||
4458 | ||||
4459 | // We might have an object without a section header. In this case the size of | |||
4460 | // Symbols is zero, because there is no way to know the size of the dynamic | |||
4461 | // table. We should allow this case and not print a warning. | |||
4462 | if (!Symbols.empty() && Reloc.Symbol >= Symbols.size()) | |||
4463 | return WarnAndReturn( | |||
4464 | nullptr, | |||
4465 | "index is greater than or equal to the number of dynamic symbols (" + | |||
4466 | Twine(Symbols.size()) + ")"); | |||
4467 | ||||
4468 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
4469 | const uint64_t FileSize = Obj.getBufSize(); | |||
4470 | const uint64_t SymOffset = ((const uint8_t *)FirstSym - Obj.base()) + | |||
4471 | (uint64_t)Reloc.Symbol * sizeof(Elf_Sym); | |||
4472 | if (SymOffset + sizeof(Elf_Sym) > FileSize) | |||
4473 | return WarnAndReturn(nullptr, "symbol at 0x" + Twine::utohexstr(SymOffset) + | |||
4474 | " goes past the end of the file (0x" + | |||
4475 | Twine::utohexstr(FileSize) + ")"); | |||
4476 | ||||
4477 | const Elf_Sym *Sym = FirstSym + Reloc.Symbol; | |||
4478 | Expected<StringRef> ErrOrName = Sym->getName(Dumper.getDynamicStringTable()); | |||
4479 | if (!ErrOrName) | |||
4480 | return WarnAndReturn(Sym, toString(ErrOrName.takeError())); | |||
4481 | ||||
4482 | return {Sym == FirstSym ? nullptr : Sym, maybeDemangle(*ErrOrName)}; | |||
4483 | } | |||
4484 | } // namespace | |||
4485 | ||||
4486 | template <class ELFT> | |||
4487 | static size_t getMaxDynamicTagSize(const ELFFile<ELFT> &Obj, | |||
4488 | typename ELFT::DynRange Tags) { | |||
4489 | size_t Max = 0; | |||
4490 | for (const typename ELFT::Dyn &Dyn : Tags) | |||
4491 | Max = std::max(Max, Obj.getDynamicTagAsString(Dyn.d_tag).size()); | |||
4492 | return Max; | |||
4493 | } | |||
4494 | ||||
4495 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicTable() { | |||
4496 | Elf_Dyn_Range Table = this->dynamic_table(); | |||
4497 | if (Table.empty()) | |||
4498 | return; | |||
4499 | ||||
4500 | OS << "Dynamic section at offset " | |||
4501 | << format_hex(reinterpret_cast<const uint8_t *>(this->DynamicTable.Addr) - | |||
4502 | this->Obj.base(), | |||
4503 | 1) | |||
4504 | << " contains " << Table.size() << " entries:\n"; | |||
4505 | ||||
4506 | // The type name is surrounded with round brackets, hence add 2. | |||
4507 | size_t MaxTagSize = getMaxDynamicTagSize(this->Obj, Table) + 2; | |||
4508 | // The "Name/Value" column should be indented from the "Type" column by N | |||
4509 | // spaces, where N = MaxTagSize - length of "Type" (4) + trailing | |||
4510 | // space (1) = 3. | |||
4511 | OS << " Tag" + std::string(ELFT::Is64Bits ? 16 : 8, ' ') + "Type" | |||
4512 | << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; | |||
4513 | ||||
4514 | std::string ValueFmt = " %-" + std::to_string(MaxTagSize) + "s "; | |||
4515 | for (auto Entry : Table) { | |||
4516 | uintX_t Tag = Entry.getTag(); | |||
4517 | std::string Type = | |||
4518 | std::string("(") + this->Obj.getDynamicTagAsString(Tag) + ")"; | |||
4519 | std::string Value = this->getDynamicEntry(Tag, Entry.getVal()); | |||
4520 | OS << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10) | |||
4521 | << format(ValueFmt.c_str(), Type.c_str()) << Value << "\n"; | |||
4522 | } | |||
4523 | } | |||
4524 | ||||
4525 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicRelocations() { | |||
4526 | this->printDynamicRelocationsHelper(); | |||
4527 | } | |||
4528 | ||||
4529 | template <class ELFT> | |||
4530 | void ELFDumper<ELFT>::printDynamicReloc(const Relocation<ELFT> &R) { | |||
4531 | printRelRelaReloc(R, getSymbolForReloc(*this, R)); | |||
4532 | } | |||
4533 | ||||
4534 | template <class ELFT> | |||
4535 | void ELFDumper<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) { | |||
4536 | this->forEachRelocationDo( | |||
4537 | Sec, opts::RawRelr, | |||
4538 | [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec, | |||
4539 | const Elf_Shdr *SymTab) { printReloc(R, Ndx, Sec, SymTab); }, | |||
4540 | [&](const Elf_Relr &R) { printRelrReloc(R); }); | |||
4541 | } | |||
4542 | ||||
4543 | template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocationsHelper() { | |||
4544 | const bool IsMips64EL = this->Obj.isMips64EL(); | |||
4545 | if (this->DynRelaRegion.Size > 0) { | |||
4546 | printDynamicRelocHeader(ELF::SHT_RELA, "RELA", this->DynRelaRegion); | |||
4547 | for (const Elf_Rela &Rela : | |||
4548 | this->DynRelaRegion.template getAsArrayRef<Elf_Rela>()) | |||
4549 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4550 | } | |||
4551 | ||||
4552 | if (this->DynRelRegion.Size > 0) { | |||
4553 | printDynamicRelocHeader(ELF::SHT_REL, "REL", this->DynRelRegion); | |||
4554 | for (const Elf_Rel &Rel : | |||
4555 | this->DynRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4556 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4557 | } | |||
4558 | ||||
4559 | if (this->DynRelrRegion.Size > 0) { | |||
4560 | printDynamicRelocHeader(ELF::SHT_REL, "RELR", this->DynRelrRegion); | |||
4561 | Elf_Relr_Range Relrs = | |||
4562 | this->DynRelrRegion.template getAsArrayRef<Elf_Relr>(); | |||
4563 | for (const Elf_Rel &Rel : Obj.decode_relrs(Relrs)) | |||
4564 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4565 | } | |||
4566 | ||||
4567 | if (this->DynPLTRelRegion.Size) { | |||
4568 | if (this->DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { | |||
4569 | printDynamicRelocHeader(ELF::SHT_RELA, "PLT", this->DynPLTRelRegion); | |||
4570 | for (const Elf_Rela &Rela : | |||
4571 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rela>()) | |||
4572 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4573 | } else { | |||
4574 | printDynamicRelocHeader(ELF::SHT_REL, "PLT", this->DynPLTRelRegion); | |||
4575 | for (const Elf_Rel &Rel : | |||
4576 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4577 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4578 | } | |||
4579 | } | |||
4580 | } | |||
4581 | ||||
4582 | template <class ELFT> | |||
4583 | void GNUELFDumper<ELFT>::printGNUVersionSectionProlog( | |||
4584 | const typename ELFT::Shdr &Sec, const Twine &Label, unsigned EntriesNum) { | |||
4585 | // Don't inline the SecName, because it might report a warning to stderr and | |||
4586 | // corrupt the output. | |||
4587 | StringRef SecName = this->getPrintableSectionName(Sec); | |||
4588 | OS << Label << " section '" << SecName << "' " | |||
4589 | << "contains " << EntriesNum << " entries:\n"; | |||
4590 | ||||
4591 | StringRef LinkedSecName = "<corrupt>"; | |||
4592 | if (Expected<const typename ELFT::Shdr *> LinkedSecOrErr = | |||
4593 | this->Obj.getSection(Sec.sh_link)) | |||
4594 | LinkedSecName = this->getPrintableSectionName(**LinkedSecOrErr); | |||
4595 | else | |||
4596 | this->reportUniqueWarning("invalid section linked to " + | |||
4597 | this->describe(Sec) + ": " + | |||
4598 | toString(LinkedSecOrErr.takeError())); | |||
4599 | ||||
4600 | OS << " Addr: " << format_hex_no_prefix(Sec.sh_addr, 16) | |||
4601 | << " Offset: " << format_hex(Sec.sh_offset, 8) | |||
4602 | << " Link: " << Sec.sh_link << " (" << LinkedSecName << ")\n"; | |||
4603 | } | |||
4604 | ||||
4605 | template <class ELFT> | |||
4606 | void GNUELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) { | |||
4607 | if (!Sec) | |||
4608 | return; | |||
4609 | ||||
4610 | printGNUVersionSectionProlog(*Sec, "Version symbols", | |||
4611 | Sec->sh_size / sizeof(Elf_Versym)); | |||
4612 | Expected<ArrayRef<Elf_Versym>> VerTableOrErr = | |||
4613 | this->getVersionTable(*Sec, /*SymTab=*/nullptr, | |||
4614 | /*StrTab=*/nullptr, /*SymTabSec=*/nullptr); | |||
4615 | if (!VerTableOrErr) { | |||
4616 | this->reportUniqueWarning(VerTableOrErr.takeError()); | |||
4617 | return; | |||
4618 | } | |||
4619 | ||||
4620 | SmallVector<std::optional<VersionEntry>, 0> *VersionMap = nullptr; | |||
4621 | if (Expected<SmallVector<std::optional<VersionEntry>, 0> *> MapOrErr = | |||
4622 | this->getVersionMap()) | |||
4623 | VersionMap = *MapOrErr; | |||
4624 | else | |||
4625 | this->reportUniqueWarning(MapOrErr.takeError()); | |||
4626 | ||||
4627 | ArrayRef<Elf_Versym> VerTable = *VerTableOrErr; | |||
4628 | std::vector<StringRef> Versions; | |||
4629 | for (size_t I = 0, E = VerTable.size(); I < E; ++I) { | |||
4630 | unsigned Ndx = VerTable[I].vs_index; | |||
4631 | if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) { | |||
4632 | Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*"); | |||
4633 | continue; | |||
4634 | } | |||
4635 | ||||
4636 | if (!VersionMap) { | |||
4637 | Versions.emplace_back("<corrupt>"); | |||
4638 | continue; | |||
4639 | } | |||
4640 | ||||
4641 | bool IsDefault; | |||
4642 | Expected<StringRef> NameOrErr = this->Obj.getSymbolVersionByIndex( | |||
4643 | Ndx, IsDefault, *VersionMap, /*IsSymHidden=*/std::nullopt); | |||
4644 | if (!NameOrErr) { | |||
4645 | this->reportUniqueWarning("unable to get a version for entry " + | |||
4646 | Twine(I) + " of " + this->describe(*Sec) + | |||
4647 | ": " + toString(NameOrErr.takeError())); | |||
4648 | Versions.emplace_back("<corrupt>"); | |||
4649 | continue; | |||
4650 | } | |||
4651 | Versions.emplace_back(*NameOrErr); | |||
4652 | } | |||
4653 | ||||
4654 | // readelf prints 4 entries per line. | |||
4655 | uint64_t Entries = VerTable.size(); | |||
4656 | for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) { | |||
4657 | OS << " " << format_hex_no_prefix(VersymRow, 3) << ":"; | |||
4658 | for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) { | |||
4659 | unsigned Ndx = VerTable[VersymRow + I].vs_index; | |||
4660 | OS << format("%4x%c", Ndx & VERSYM_VERSION, | |||
4661 | Ndx & VERSYM_HIDDEN ? 'h' : ' '); | |||
4662 | OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13); | |||
4663 | } | |||
4664 | OS << '\n'; | |||
4665 | } | |||
4666 | OS << '\n'; | |||
4667 | } | |||
4668 | ||||
4669 | static std::string versionFlagToString(unsigned Flags) { | |||
4670 | if (Flags == 0) | |||
4671 | return "none"; | |||
4672 | ||||
4673 | std::string Ret; | |||
4674 | auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) { | |||
4675 | if (!(Flags & Flag)) | |||
4676 | return; | |||
4677 | if (!Ret.empty()) | |||
4678 | Ret += " | "; | |||
4679 | Ret += Name; | |||
4680 | Flags &= ~Flag; | |||
4681 | }; | |||
4682 | ||||
4683 | AddFlag(VER_FLG_BASE, "BASE"); | |||
4684 | AddFlag(VER_FLG_WEAK, "WEAK"); | |||
4685 | AddFlag(VER_FLG_INFO, "INFO"); | |||
4686 | AddFlag(~0, "<unknown>"); | |||
4687 | return Ret; | |||
4688 | } | |||
4689 | ||||
4690 | template <class ELFT> | |||
4691 | void GNUELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) { | |||
4692 | if (!Sec) | |||
4693 | return; | |||
4694 | ||||
4695 | printGNUVersionSectionProlog(*Sec, "Version definition", Sec->sh_info); | |||
4696 | ||||
4697 | Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec); | |||
4698 | if (!V) { | |||
4699 | this->reportUniqueWarning(V.takeError()); | |||
4700 | return; | |||
4701 | } | |||
4702 | ||||
4703 | for (const VerDef &Def : *V) { | |||
4704 | OS << format(" 0x%04x: Rev: %u Flags: %s Index: %u Cnt: %u Name: %s\n", | |||
4705 | Def.Offset, Def.Version, | |||
4706 | versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt, | |||
4707 | Def.Name.data()); | |||
4708 | unsigned I = 0; | |||
4709 | for (const VerdAux &Aux : Def.AuxV) | |||
4710 | OS << format(" 0x%04x: Parent %u: %s\n", Aux.Offset, ++I, | |||
4711 | Aux.Name.data()); | |||
4712 | } | |||
4713 | ||||
4714 | OS << '\n'; | |||
4715 | } | |||
4716 | ||||
4717 | template <class ELFT> | |||
4718 | void GNUELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) { | |||
4719 | if (!Sec) | |||
4720 | return; | |||
4721 | ||||
4722 | unsigned VerneedNum = Sec->sh_info; | |||
4723 | printGNUVersionSectionProlog(*Sec, "Version needs", VerneedNum); | |||
4724 | ||||
4725 | Expected<std::vector<VerNeed>> V = | |||
4726 | this->Obj.getVersionDependencies(*Sec, this->WarningHandler); | |||
4727 | if (!V) { | |||
4728 | this->reportUniqueWarning(V.takeError()); | |||
4729 | return; | |||
4730 | } | |||
4731 | ||||
4732 | for (const VerNeed &VN : *V) { | |||
4733 | OS << format(" 0x%04x: Version: %u File: %s Cnt: %u\n", VN.Offset, | |||
4734 | VN.Version, VN.File.data(), VN.Cnt); | |||
4735 | for (const VernAux &Aux : VN.AuxV) | |||
4736 | OS << format(" 0x%04x: Name: %s Flags: %s Version: %u\n", Aux.Offset, | |||
4737 | Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(), | |||
4738 | Aux.Other); | |||
4739 | } | |||
4740 | OS << '\n'; | |||
4741 | } | |||
4742 | ||||
4743 | template <class ELFT> | |||
4744 | void GNUELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) { | |||
4745 | size_t NBucket = HashTable.nbucket; | |||
4746 | size_t NChain = HashTable.nchain; | |||
4747 | ArrayRef<Elf_Word> Buckets = HashTable.buckets(); | |||
4748 | ArrayRef<Elf_Word> Chains = HashTable.chains(); | |||
4749 | size_t TotalSyms = 0; | |||
4750 | // If hash table is correct, we have at least chains with 0 length | |||
4751 | size_t MaxChain = 1; | |||
4752 | size_t CumulativeNonZero = 0; | |||
4753 | ||||
4754 | if (NChain == 0 || NBucket == 0) | |||
4755 | return; | |||
4756 | ||||
4757 | std::vector<size_t> ChainLen(NBucket, 0); | |||
4758 | // Go over all buckets and and note chain lengths of each bucket (total | |||
4759 | // unique chain lengths). | |||
4760 | for (size_t B = 0; B < NBucket; B++) { | |||
4761 | BitVector Visited(NChain); | |||
4762 | for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) { | |||
4763 | if (C == ELF::STN_UNDEF) | |||
4764 | break; | |||
4765 | if (Visited[C]) { | |||
4766 | this->reportUniqueWarning(".hash section is invalid: bucket " + | |||
4767 | Twine(C) + | |||
4768 | ": a cycle was detected in the linked chain"); | |||
4769 | break; | |||
4770 | } | |||
4771 | Visited[C] = true; | |||
4772 | if (MaxChain <= ++ChainLen[B]) | |||
4773 | MaxChain++; | |||
4774 | } | |||
4775 | TotalSyms += ChainLen[B]; | |||
4776 | } | |||
4777 | ||||
4778 | if (!TotalSyms) | |||
4779 | return; | |||
4780 | ||||
4781 | std::vector<size_t> Count(MaxChain, 0); | |||
4782 | // Count how long is the chain for each bucket | |||
4783 | for (size_t B = 0; B < NBucket; B++) | |||
4784 | ++Count[ChainLen[B]]; | |||
4785 | // Print Number of buckets with each chain lengths and their cumulative | |||
4786 | // coverage of the symbols | |||
4787 | OS << "Histogram for bucket list length (total of " << NBucket | |||
4788 | << " buckets)\n" | |||
4789 | << " Length Number % of total Coverage\n"; | |||
4790 | for (size_t I = 0; I < MaxChain; I++) { | |||
4791 | CumulativeNonZero += Count[I] * I; | |||
4792 | OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], | |||
4793 | (Count[I] * 100.0) / NBucket, | |||
4794 | (CumulativeNonZero * 100.0) / TotalSyms); | |||
4795 | } | |||
4796 | } | |||
4797 | ||||
4798 | template <class ELFT> | |||
4799 | void GNUELFDumper<ELFT>::printGnuHashHistogram( | |||
4800 | const Elf_GnuHash &GnuHashTable) { | |||
4801 | Expected<ArrayRef<Elf_Word>> ChainsOrErr = | |||
4802 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHashTable); | |||
4803 | if (!ChainsOrErr) { | |||
4804 | this->reportUniqueWarning("unable to print the GNU hash table histogram: " + | |||
4805 | toString(ChainsOrErr.takeError())); | |||
4806 | return; | |||
4807 | } | |||
4808 | ||||
4809 | ArrayRef<Elf_Word> Chains = *ChainsOrErr; | |||
4810 | size_t Symndx = GnuHashTable.symndx; | |||
4811 | size_t TotalSyms = 0; | |||
4812 | size_t MaxChain = 1; | |||
4813 | size_t CumulativeNonZero = 0; | |||
4814 | ||||
4815 | size_t NBucket = GnuHashTable.nbuckets; | |||
4816 | if (Chains.empty() || NBucket == 0) | |||
4817 | return; | |||
4818 | ||||
4819 | ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets(); | |||
4820 | std::vector<size_t> ChainLen(NBucket, 0); | |||
4821 | for (size_t B = 0; B < NBucket; B++) { | |||
4822 | if (!Buckets[B]) | |||
4823 | continue; | |||
4824 | size_t Len = 1; | |||
4825 | for (size_t C = Buckets[B] - Symndx; | |||
4826 | C < Chains.size() && (Chains[C] & 1) == 0; C++) | |||
4827 | if (MaxChain < ++Len) | |||
4828 | MaxChain++; | |||
4829 | ChainLen[B] = Len; | |||
4830 | TotalSyms += Len; | |||
4831 | } | |||
4832 | MaxChain++; | |||
4833 | ||||
4834 | if (!TotalSyms) | |||
4835 | return; | |||
4836 | ||||
4837 | std::vector<size_t> Count(MaxChain, 0); | |||
4838 | for (size_t B = 0; B < NBucket; B++) | |||
4839 | ++Count[ChainLen[B]]; | |||
4840 | // Print Number of buckets with each chain lengths and their cumulative | |||
4841 | // coverage of the symbols | |||
4842 | OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket | |||
4843 | << " buckets)\n" | |||
4844 | << " Length Number % of total Coverage\n"; | |||
4845 | for (size_t I = 0; I < MaxChain; I++) { | |||
4846 | CumulativeNonZero += Count[I] * I; | |||
4847 | OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], | |||
4848 | (Count[I] * 100.0) / NBucket, | |||
4849 | (CumulativeNonZero * 100.0) / TotalSyms); | |||
4850 | } | |||
4851 | } | |||
4852 | ||||
4853 | // Hash histogram shows statistics of how efficient the hash was for the | |||
4854 | // dynamic symbol table. The table shows the number of hash buckets for | |||
4855 | // different lengths of chains as an absolute number and percentage of the total | |||
4856 | // buckets, and the cumulative coverage of symbols for each set of buckets. | |||
4857 | template <class ELFT> void GNUELFDumper<ELFT>::printHashHistograms() { | |||
4858 | // Print histogram for the .hash section. | |||
4859 | if (this->HashTable) { | |||
4860 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
4861 | this->reportUniqueWarning(std::move(E)); | |||
4862 | else | |||
4863 | printHashHistogram(*this->HashTable); | |||
4864 | } | |||
4865 | ||||
4866 | // Print histogram for the .gnu.hash section. | |||
4867 | if (this->GnuHashTable) { | |||
4868 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
4869 | this->reportUniqueWarning(std::move(E)); | |||
4870 | else | |||
4871 | printGnuHashHistogram(*this->GnuHashTable); | |||
4872 | } | |||
4873 | } | |||
4874 | ||||
4875 | template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() { | |||
4876 | OS << "GNUStyle::printCGProfile not implemented\n"; | |||
4877 | } | |||
4878 | ||||
4879 | template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() { | |||
4880 | OS << "GNUStyle::printBBAddrMaps not implemented\n"; | |||
4881 | } | |||
4882 | ||||
4883 | static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) { | |||
4884 | std::vector<uint64_t> Ret; | |||
4885 | const uint8_t *Cur = Data.begin(); | |||
4886 | const uint8_t *End = Data.end(); | |||
4887 | while (Cur != End) { | |||
4888 | unsigned Size; | |||
4889 | const char *Err; | |||
4890 | Ret.push_back(decodeULEB128(Cur, &Size, End, &Err)); | |||
4891 | if (Err) | |||
4892 | return createError(Err); | |||
4893 | Cur += Size; | |||
4894 | } | |||
4895 | return Ret; | |||
4896 | } | |||
4897 | ||||
4898 | template <class ELFT> | |||
4899 | static Expected<std::vector<uint64_t>> | |||
4900 | decodeAddrsigSection(const ELFFile<ELFT> &Obj, const typename ELFT::Shdr &Sec) { | |||
4901 | Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Sec); | |||
4902 | if (!ContentsOrErr) | |||
4903 | return ContentsOrErr.takeError(); | |||
4904 | ||||
4905 | if (Expected<std::vector<uint64_t>> SymsOrErr = | |||
4906 | toULEB128Array(*ContentsOrErr)) | |||
4907 | return *SymsOrErr; | |||
4908 | else | |||
4909 | return createError("unable to decode " + describe(Obj, Sec) + ": " + | |||
4910 | toString(SymsOrErr.takeError())); | |||
4911 | } | |||
4912 | ||||
4913 | template <class ELFT> void GNUELFDumper<ELFT>::printAddrsig() { | |||
4914 | if (!this->DotAddrsigSec) | |||
4915 | return; | |||
4916 | ||||
4917 | Expected<std::vector<uint64_t>> SymsOrErr = | |||
4918 | decodeAddrsigSection(this->Obj, *this->DotAddrsigSec); | |||
4919 | if (!SymsOrErr) { | |||
4920 | this->reportUniqueWarning(SymsOrErr.takeError()); | |||
4921 | return; | |||
4922 | } | |||
4923 | ||||
4924 | StringRef Name = this->getPrintableSectionName(*this->DotAddrsigSec); | |||
4925 | OS << "\nAddress-significant symbols section '" << Name << "'" | |||
4926 | << " contains " << SymsOrErr->size() << " entries:\n"; | |||
4927 | OS << " Num: Name\n"; | |||
4928 | ||||
4929 | Field Fields[2] = {0, 8}; | |||
4930 | size_t SymIndex = 0; | |||
4931 | for (uint64_t Sym : *SymsOrErr) { | |||
4932 | Fields[0].Str = to_string(format_decimal(++SymIndex, 6)) + ":"; | |||
4933 | Fields[1].Str = this->getStaticSymbolName(Sym); | |||
4934 | for (const Field &Entry : Fields) | |||
4935 | printField(Entry); | |||
4936 | OS << "\n"; | |||
4937 | } | |||
4938 | } | |||
4939 | ||||
4940 | template <typename ELFT> | |||
4941 | static std::string getGNUProperty(uint32_t Type, uint32_t DataSize, | |||
4942 | ArrayRef<uint8_t> Data) { | |||
4943 | std::string str; | |||
4944 | raw_string_ostream OS(str); | |||
4945 | uint32_t PrData; | |||
4946 | auto DumpBit = [&](uint32_t Flag, StringRef Name) { | |||
4947 | if (PrData & Flag) { | |||
4948 | PrData &= ~Flag; | |||
4949 | OS << Name; | |||
4950 | if (PrData) | |||
4951 | OS << ", "; | |||
4952 | } | |||
4953 | }; | |||
4954 | ||||
4955 | switch (Type) { | |||
4956 | default: | |||
4957 | OS << format("<application-specific type 0x%x>", Type); | |||
4958 | return OS.str(); | |||
4959 | case GNU_PROPERTY_STACK_SIZE: { | |||
4960 | OS << "stack size: "; | |||
4961 | if (DataSize == sizeof(typename ELFT::uint)) | |||
4962 | OS << formatv("{0:x}", | |||
4963 | (uint64_t)(*(const typename ELFT::Addr *)Data.data())); | |||
4964 | else | |||
4965 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4966 | return OS.str(); | |||
4967 | } | |||
4968 | case GNU_PROPERTY_NO_COPY_ON_PROTECTED: | |||
4969 | OS << "no copy on protected"; | |||
4970 | if (DataSize) | |||
4971 | OS << format(" <corrupt length: 0x%x>", DataSize); | |||
4972 | return OS.str(); | |||
4973 | case GNU_PROPERTY_AARCH64_FEATURE_1_AND: | |||
4974 | case GNU_PROPERTY_X86_FEATURE_1_AND: | |||
4975 | OS << ((Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) ? "aarch64 feature: " | |||
4976 | : "x86 feature: "); | |||
4977 | if (DataSize != 4) { | |||
4978 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
4979 | return OS.str(); | |||
4980 | } | |||
4981 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
4982 | if (PrData == 0) { | |||
4983 | OS << "<None>"; | |||
4984 | return OS.str(); | |||
4985 | } | |||
4986 | if (Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) { | |||
4987 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_BTI, "BTI"); | |||
4988 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_PAC, "PAC"); | |||
4989 | } else { | |||
4990 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_IBT, "IBT"); | |||
4991 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_SHSTK, "SHSTK"); | |||
4992 | } | |||
4993 | if (PrData) | |||
4994 | OS << format("<unknown flags: 0x%x>", PrData); | |||
4995 | return OS.str(); | |||
4996 | case GNU_PROPERTY_X86_FEATURE_2_NEEDED: | |||
4997 | case GNU_PROPERTY_X86_FEATURE_2_USED: | |||
4998 | OS << "x86 feature " | |||
4999 | << (Type == GNU_PROPERTY_X86_FEATURE_2_NEEDED ? "needed: " : "used: "); | |||
5000 | if (DataSize != 4) { | |||
5001 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5002 | return OS.str(); | |||
5003 | } | |||
5004 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
5005 | if (PrData == 0) { | |||
5006 | OS << "<None>"; | |||
5007 | return OS.str(); | |||
5008 | } | |||
5009 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X86, "x86"); | |||
5010 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X87, "x87"); | |||
5011 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_MMX, "MMX"); | |||
5012 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XMM, "XMM"); | |||
5013 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_YMM, "YMM"); | |||
5014 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_ZMM, "ZMM"); | |||
5015 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_FXSR, "FXSR"); | |||
5016 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVE, "XSAVE"); | |||
5017 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT, "XSAVEOPT"); | |||
5018 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEC, "XSAVEC"); | |||
5019 | if (PrData) | |||
5020 | OS << format("<unknown flags: 0x%x>", PrData); | |||
5021 | return OS.str(); | |||
5022 | case GNU_PROPERTY_X86_ISA_1_NEEDED: | |||
5023 | case GNU_PROPERTY_X86_ISA_1_USED: | |||
5024 | OS << "x86 ISA " | |||
5025 | << (Type == GNU_PROPERTY_X86_ISA_1_NEEDED ? "needed: " : "used: "); | |||
5026 | if (DataSize != 4) { | |||
5027 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5028 | return OS.str(); | |||
5029 | } | |||
5030 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
5031 | if (PrData == 0) { | |||
5032 | OS << "<None>"; | |||
5033 | return OS.str(); | |||
5034 | } | |||
5035 | DumpBit(GNU_PROPERTY_X86_ISA_1_BASELINE, "x86-64-baseline"); | |||
5036 | DumpBit(GNU_PROPERTY_X86_ISA_1_V2, "x86-64-v2"); | |||
5037 | DumpBit(GNU_PROPERTY_X86_ISA_1_V3, "x86-64-v3"); | |||
5038 | DumpBit(GNU_PROPERTY_X86_ISA_1_V4, "x86-64-v4"); | |||
5039 | if (PrData) | |||
5040 | OS << format("<unknown flags: 0x%x>", PrData); | |||
5041 | return OS.str(); | |||
5042 | } | |||
5043 | } | |||
5044 | ||||
5045 | template <typename ELFT> | |||
5046 | static SmallVector<std::string, 4> getGNUPropertyList(ArrayRef<uint8_t> Arr) { | |||
5047 | using Elf_Word = typename ELFT::Word; | |||
5048 | ||||
5049 | SmallVector<std::string, 4> Properties; | |||
5050 | while (Arr.size() >= 8) { | |||
5051 | uint32_t Type = *reinterpret_cast<const Elf_Word *>(Arr.data()); | |||
5052 | uint32_t DataSize = *reinterpret_cast<const Elf_Word *>(Arr.data() + 4); | |||
5053 | Arr = Arr.drop_front(8); | |||
5054 | ||||
5055 | // Take padding size into account if present. | |||
5056 | uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint)); | |||
5057 | std::string str; | |||
5058 | raw_string_ostream OS(str); | |||
5059 | if (Arr.size() < PaddedSize) { | |||
5060 | OS << format("<corrupt type (0x%x) datasz: 0x%x>", Type, DataSize); | |||
5061 | Properties.push_back(OS.str()); | |||
5062 | break; | |||
5063 | } | |||
5064 | Properties.push_back( | |||
5065 | getGNUProperty<ELFT>(Type, DataSize, Arr.take_front(PaddedSize))); | |||
5066 | Arr = Arr.drop_front(PaddedSize); | |||
5067 | } | |||
5068 | ||||
5069 | if (!Arr.empty()) | |||
5070 | Properties.push_back("<corrupted GNU_PROPERTY_TYPE_0>"); | |||
5071 | ||||
5072 | return Properties; | |||
5073 | } | |||
5074 | ||||
5075 | struct GNUAbiTag { | |||
5076 | std::string OSName; | |||
5077 | std::string ABI; | |||
5078 | bool IsValid; | |||
5079 | }; | |||
5080 | ||||
5081 | template <typename ELFT> static GNUAbiTag getGNUAbiTag(ArrayRef<uint8_t> Desc) { | |||
5082 | typedef typename ELFT::Word Elf_Word; | |||
5083 | ||||
5084 | ArrayRef<Elf_Word> Words(reinterpret_cast<const Elf_Word *>(Desc.begin()), | |||
5085 | reinterpret_cast<const Elf_Word *>(Desc.end())); | |||
5086 | ||||
5087 | if (Words.size() < 4) | |||
5088 | return {"", "", /*IsValid=*/false}; | |||
5089 | ||||
5090 | static const char *OSNames[] = { | |||
5091 | "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl", | |||
5092 | }; | |||
5093 | StringRef OSName = "Unknown"; | |||
5094 | if (Words[0] < std::size(OSNames)) | |||
5095 | OSName = OSNames[Words[0]]; | |||
5096 | uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3]; | |||
5097 | std::string str; | |||
5098 | raw_string_ostream ABI(str); | |||
5099 | ABI << Major << "." << Minor << "." << Patch; | |||
5100 | return {std::string(OSName), ABI.str(), /*IsValid=*/true}; | |||
5101 | } | |||
5102 | ||||
5103 | static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) { | |||
5104 | std::string str; | |||
5105 | raw_string_ostream OS(str); | |||
5106 | for (uint8_t B : Desc) | |||
5107 | OS << format_hex_no_prefix(B, 2); | |||
5108 | return OS.str(); | |||
5109 | } | |||
5110 | ||||
5111 | static StringRef getDescAsStringRef(ArrayRef<uint8_t> Desc) { | |||
5112 | return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5113 | } | |||
5114 | ||||
5115 | template <typename ELFT> | |||
5116 | static bool printGNUNote(raw_ostream &OS, uint32_t NoteType, | |||
5117 | ArrayRef<uint8_t> Desc) { | |||
5118 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5119 | switch (NoteType) { | |||
5120 | default: | |||
5121 | return false; | |||
5122 | case ELF::NT_GNU_ABI_TAG: { | |||
5123 | const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); | |||
5124 | if (!AbiTag.IsValid) | |||
5125 | OS << " <corrupt GNU_ABI_TAG>"; | |||
5126 | else | |||
5127 | OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI; | |||
5128 | break; | |||
5129 | } | |||
5130 | case ELF::NT_GNU_BUILD_ID: { | |||
5131 | OS << " Build ID: " << getGNUBuildId(Desc); | |||
5132 | break; | |||
5133 | } | |||
5134 | case ELF::NT_GNU_GOLD_VERSION: | |||
5135 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5136 | break; | |||
5137 | case ELF::NT_GNU_PROPERTY_TYPE_0: | |||
5138 | OS << " Properties:"; | |||
5139 | for (const std::string &Property : getGNUPropertyList<ELFT>(Desc)) | |||
5140 | OS << " " << Property << "\n"; | |||
5141 | break; | |||
5142 | } | |||
5143 | OS << '\n'; | |||
5144 | return true; | |||
5145 | } | |||
5146 | ||||
5147 | using AndroidNoteProperties = std::vector<std::pair<StringRef, std::string>>; | |||
5148 | static AndroidNoteProperties getAndroidNoteProperties(uint32_t NoteType, | |||
5149 | ArrayRef<uint8_t> Desc) { | |||
5150 | AndroidNoteProperties Props; | |||
5151 | switch (NoteType) { | |||
5152 | case ELF::NT_ANDROID_TYPE_MEMTAG: | |||
5153 | if (Desc.empty()) { | |||
5154 | Props.emplace_back("Invalid .note.android.memtag", ""); | |||
5155 | return Props; | |||
5156 | } | |||
5157 | ||||
5158 | switch (Desc[0] & NT_MEMTAG_LEVEL_MASK) { | |||
5159 | case NT_MEMTAG_LEVEL_NONE: | |||
5160 | Props.emplace_back("Tagging Mode", "NONE"); | |||
5161 | break; | |||
5162 | case NT_MEMTAG_LEVEL_ASYNC: | |||
5163 | Props.emplace_back("Tagging Mode", "ASYNC"); | |||
5164 | break; | |||
5165 | case NT_MEMTAG_LEVEL_SYNC: | |||
5166 | Props.emplace_back("Tagging Mode", "SYNC"); | |||
5167 | break; | |||
5168 | default: | |||
5169 | Props.emplace_back( | |||
5170 | "Tagging Mode", | |||
5171 | ("Unknown (" + Twine::utohexstr(Desc[0] & NT_MEMTAG_LEVEL_MASK) + ")") | |||
5172 | .str()); | |||
5173 | break; | |||
5174 | } | |||
5175 | Props.emplace_back("Heap", | |||
5176 | (Desc[0] & NT_MEMTAG_HEAP) ? "Enabled" : "Disabled"); | |||
5177 | Props.emplace_back("Stack", | |||
5178 | (Desc[0] & NT_MEMTAG_STACK) ? "Enabled" : "Disabled"); | |||
5179 | break; | |||
5180 | default: | |||
5181 | return Props; | |||
5182 | } | |||
5183 | return Props; | |||
5184 | } | |||
5185 | ||||
5186 | static bool printAndroidNote(raw_ostream &OS, uint32_t NoteType, | |||
5187 | ArrayRef<uint8_t> Desc) { | |||
5188 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5189 | AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc); | |||
5190 | if (Props.empty()) | |||
5191 | return false; | |||
5192 | for (const auto &KV : Props) | |||
5193 | OS << " " << KV.first << ": " << KV.second << '\n'; | |||
5194 | OS << '\n'; | |||
5195 | return true; | |||
5196 | } | |||
5197 | ||||
5198 | template <typename ELFT> | |||
5199 | static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType, | |||
5200 | ArrayRef<uint8_t> Desc) { | |||
5201 | switch (NoteType) { | |||
5202 | default: | |||
5203 | return false; | |||
5204 | case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION: | |||
5205 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5206 | break; | |||
5207 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER: | |||
5208 | OS << " Producer: " << getDescAsStringRef(Desc); | |||
5209 | break; | |||
5210 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION: | |||
5211 | OS << " Producer version: " << getDescAsStringRef(Desc); | |||
5212 | break; | |||
5213 | } | |||
5214 | OS << '\n'; | |||
5215 | return true; | |||
5216 | } | |||
5217 | ||||
5218 | const EnumEntry<unsigned> FreeBSDFeatureCtlFlags[] = { | |||
5219 | {"ASLR_DISABLE", NT_FREEBSD_FCTL_ASLR_DISABLE}, | |||
5220 | {"PROTMAX_DISABLE", NT_FREEBSD_FCTL_PROTMAX_DISABLE}, | |||
5221 | {"STKGAP_DISABLE", NT_FREEBSD_FCTL_STKGAP_DISABLE}, | |||
5222 | {"WXNEEDED", NT_FREEBSD_FCTL_WXNEEDED}, | |||
5223 | {"LA48", NT_FREEBSD_FCTL_LA48}, | |||
5224 | {"ASG_DISABLE", NT_FREEBSD_FCTL_ASG_DISABLE}, | |||
5225 | }; | |||
5226 | ||||
5227 | struct FreeBSDNote { | |||
5228 | std::string Type; | |||
5229 | std::string Value; | |||
5230 | }; | |||
5231 | ||||
5232 | template <typename ELFT> | |||
5233 | static Optional<FreeBSDNote> | |||
5234 | getFreeBSDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc, bool IsCore) { | |||
5235 | if (IsCore) | |||
5236 | return std::nullopt; // No pretty-printing yet. | |||
5237 | switch (NoteType) { | |||
5238 | case ELF::NT_FREEBSD_ABI_TAG: | |||
5239 | if (Desc.size() != 4) | |||
5240 | return std::nullopt; | |||
5241 | return FreeBSDNote{ | |||
5242 | "ABI tag", | |||
5243 | utostr(support::endian::read32<ELFT::TargetEndianness>(Desc.data()))}; | |||
5244 | case ELF::NT_FREEBSD_ARCH_TAG: | |||
5245 | return FreeBSDNote{"Arch tag", toStringRef(Desc).str()}; | |||
5246 | case ELF::NT_FREEBSD_FEATURE_CTL: { | |||
5247 | if (Desc.size() != 4) | |||
5248 | return std::nullopt; | |||
5249 | unsigned Value = | |||
5250 | support::endian::read32<ELFT::TargetEndianness>(Desc.data()); | |||
5251 | std::string FlagsStr; | |||
5252 | raw_string_ostream OS(FlagsStr); | |||
5253 | printFlags(Value, makeArrayRef(FreeBSDFeatureCtlFlags), OS); | |||
5254 | if (OS.str().empty()) | |||
5255 | OS << "0x" << utohexstr(Value); | |||
5256 | else | |||
5257 | OS << "(0x" << utohexstr(Value) << ")"; | |||
5258 | return FreeBSDNote{"Feature flags", OS.str()}; | |||
5259 | } | |||
5260 | default: | |||
5261 | return std::nullopt; | |||
5262 | } | |||
5263 | } | |||
5264 | ||||
5265 | struct AMDNote { | |||
5266 | std::string Type; | |||
5267 | std::string Value; | |||
5268 | }; | |||
5269 | ||||
5270 | template <typename ELFT> | |||
5271 | static AMDNote getAMDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5272 | switch (NoteType) { | |||
5273 | default: | |||
5274 | return {"", ""}; | |||
5275 | case ELF::NT_AMD_HSA_CODE_OBJECT_VERSION: { | |||
5276 | struct CodeObjectVersion { | |||
5277 | uint32_t MajorVersion; | |||
5278 | uint32_t MinorVersion; | |||
5279 | }; | |||
5280 | if (Desc.size() != sizeof(CodeObjectVersion)) | |||
5281 | return {"AMD HSA Code Object Version", | |||
5282 | "Invalid AMD HSA Code Object Version"}; | |||
5283 | std::string VersionString; | |||
5284 | raw_string_ostream StrOS(VersionString); | |||
5285 | auto Version = reinterpret_cast<const CodeObjectVersion *>(Desc.data()); | |||
5286 | StrOS << "[Major: " << Version->MajorVersion | |||
5287 | << ", Minor: " << Version->MinorVersion << "]"; | |||
5288 | return {"AMD HSA Code Object Version", VersionString}; | |||
5289 | } | |||
5290 | case ELF::NT_AMD_HSA_HSAIL: { | |||
5291 | struct HSAILProperties { | |||
5292 | uint32_t HSAILMajorVersion; | |||
5293 | uint32_t HSAILMinorVersion; | |||
5294 | uint8_t Profile; | |||
5295 | uint8_t MachineModel; | |||
5296 | uint8_t DefaultFloatRound; | |||
5297 | }; | |||
5298 | if (Desc.size() != sizeof(HSAILProperties)) | |||
5299 | return {"AMD HSA HSAIL Properties", "Invalid AMD HSA HSAIL Properties"}; | |||
5300 | auto Properties = reinterpret_cast<const HSAILProperties *>(Desc.data()); | |||
5301 | std::string HSAILPropetiesString; | |||
5302 | raw_string_ostream StrOS(HSAILPropetiesString); | |||
5303 | StrOS << "[HSAIL Major: " << Properties->HSAILMajorVersion | |||
5304 | << ", HSAIL Minor: " << Properties->HSAILMinorVersion | |||
5305 | << ", Profile: " << uint32_t(Properties->Profile) | |||
5306 | << ", Machine Model: " << uint32_t(Properties->MachineModel) | |||
5307 | << ", Default Float Round: " | |||
5308 | << uint32_t(Properties->DefaultFloatRound) << "]"; | |||
5309 | return {"AMD HSA HSAIL Properties", HSAILPropetiesString}; | |||
5310 | } | |||
5311 | case ELF::NT_AMD_HSA_ISA_VERSION: { | |||
5312 | struct IsaVersion { | |||
5313 | uint16_t VendorNameSize; | |||
5314 | uint16_t ArchitectureNameSize; | |||
5315 | uint32_t Major; | |||
5316 | uint32_t Minor; | |||
5317 | uint32_t Stepping; | |||
5318 | }; | |||
5319 | if (Desc.size() < sizeof(IsaVersion)) | |||
5320 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5321 | auto Isa = reinterpret_cast<const IsaVersion *>(Desc.data()); | |||
5322 | if (Desc.size() < sizeof(IsaVersion) + | |||
5323 | Isa->VendorNameSize + Isa->ArchitectureNameSize || | |||
5324 | Isa->VendorNameSize == 0 || Isa->ArchitectureNameSize == 0) | |||
5325 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5326 | std::string IsaString; | |||
5327 | raw_string_ostream StrOS(IsaString); | |||
5328 | StrOS << "[Vendor: " | |||
5329 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion), Isa->VendorNameSize - 1) | |||
5330 | << ", Architecture: " | |||
5331 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion) + Isa->VendorNameSize, | |||
5332 | Isa->ArchitectureNameSize - 1) | |||
5333 | << ", Major: " << Isa->Major << ", Minor: " << Isa->Minor | |||
5334 | << ", Stepping: " << Isa->Stepping << "]"; | |||
5335 | return {"AMD HSA ISA Version", IsaString}; | |||
5336 | } | |||
5337 | case ELF::NT_AMD_HSA_METADATA: { | |||
5338 | if (Desc.size() == 0) | |||
5339 | return {"AMD HSA Metadata", ""}; | |||
5340 | return { | |||
5341 | "AMD HSA Metadata", | |||
5342 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size() - 1)}; | |||
5343 | } | |||
5344 | case ELF::NT_AMD_HSA_ISA_NAME: { | |||
5345 | if (Desc.size() == 0) | |||
5346 | return {"AMD HSA ISA Name", ""}; | |||
5347 | return { | |||
5348 | "AMD HSA ISA Name", | |||
5349 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())}; | |||
5350 | } | |||
5351 | case ELF::NT_AMD_PAL_METADATA: { | |||
5352 | struct PALMetadata { | |||
5353 | uint32_t Key; | |||
5354 | uint32_t Value; | |||
5355 | }; | |||
5356 | if (Desc.size() % sizeof(PALMetadata) != 0) | |||
5357 | return {"AMD PAL Metadata", "Invalid AMD PAL Metadata"}; | |||
5358 | auto Isa = reinterpret_cast<const PALMetadata *>(Desc.data()); | |||
5359 | std::string MetadataString; | |||
5360 | raw_string_ostream StrOS(MetadataString); | |||
5361 | for (size_t I = 0, E = Desc.size() / sizeof(PALMetadata); I < E; ++I) { | |||
5362 | StrOS << "[" << Isa[I].Key << ": " << Isa[I].Value << "]"; | |||
5363 | } | |||
5364 | return {"AMD PAL Metadata", MetadataString}; | |||
5365 | } | |||
5366 | } | |||
5367 | } | |||
5368 | ||||
5369 | struct AMDGPUNote { | |||
5370 | std::string Type; | |||
5371 | std::string Value; | |||
5372 | }; | |||
5373 | ||||
5374 | template <typename ELFT> | |||
5375 | static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5376 | switch (NoteType) { | |||
5377 | default: | |||
5378 | return {"", ""}; | |||
5379 | case ELF::NT_AMDGPU_METADATA: { | |||
5380 | StringRef MsgPackString = | |||
5381 | StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5382 | msgpack::Document MsgPackDoc; | |||
5383 | if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false)) | |||
5384 | return {"", ""}; | |||
5385 | ||||
5386 | AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true); | |||
5387 | std::string MetadataString; | |||
5388 | if (!Verifier.verify(MsgPackDoc.getRoot())) | |||
5389 | MetadataString = "Invalid AMDGPU Metadata\n"; | |||
5390 | ||||
5391 | raw_string_ostream StrOS(MetadataString); | |||
5392 | if (MsgPackDoc.getRoot().isScalar()) { | |||
5393 | // TODO: passing a scalar root to toYAML() asserts: | |||
5394 | // (PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && | |||
5395 | // "plain scalar documents are not supported") | |||
5396 | // To avoid this crash we print the raw data instead. | |||
5397 | return {"", ""}; | |||
5398 | } | |||
5399 | MsgPackDoc.toYAML(StrOS); | |||
5400 | return {"AMDGPU Metadata", StrOS.str()}; | |||
5401 | } | |||
5402 | } | |||
5403 | } | |||
5404 | ||||
5405 | struct CoreFileMapping { | |||
5406 | uint64_t Start, End, Offset; | |||
5407 | StringRef Filename; | |||
5408 | }; | |||
5409 | ||||
5410 | struct CoreNote { | |||
5411 | uint64_t PageSize; | |||
5412 | std::vector<CoreFileMapping> Mappings; | |||
5413 | }; | |||
5414 | ||||
5415 | static Expected<CoreNote> readCoreNote(DataExtractor Desc) { | |||
5416 | // Expected format of the NT_FILE note description: | |||
5417 | // 1. # of file mappings (call it N) | |||
5418 | // 2. Page size | |||
5419 | // 3. N (start, end, offset) triples | |||
5420 | // 4. N packed filenames (null delimited) | |||
5421 | // Each field is an Elf_Addr, except for filenames which are char* strings. | |||
5422 | ||||
5423 | CoreNote Ret; | |||
5424 | const int Bytes = Desc.getAddressSize(); | |||
5425 | ||||
5426 | if (!Desc.isValidOffsetForAddress(2)) | |||
5427 | return createError("the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5428 | " is too short, expected at least 0x" + | |||
5429 | Twine::utohexstr(Bytes * 2)); | |||
5430 | if (Desc.getData().back() != 0) | |||
5431 | return createError("the note is not NUL terminated"); | |||
5432 | ||||
5433 | uint64_t DescOffset = 0; | |||
5434 | uint64_t FileCount = Desc.getAddress(&DescOffset); | |||
5435 | Ret.PageSize = Desc.getAddress(&DescOffset); | |||
5436 | ||||
5437 | if (!Desc.isValidOffsetForAddress(3 * FileCount * Bytes)) | |||
5438 | return createError("unable to read file mappings (found " + | |||
5439 | Twine(FileCount) + "): the note of size 0x" + | |||
5440 | Twine::utohexstr(Desc.size()) + " is too short"); | |||
5441 | ||||
5442 | uint64_t FilenamesOffset = 0; | |||
5443 | DataExtractor Filenames( | |||
5444 | Desc.getData().drop_front(DescOffset + 3 * FileCount * Bytes), | |||
5445 | Desc.isLittleEndian(), Desc.getAddressSize()); | |||
5446 | ||||
5447 | Ret.Mappings.resize(FileCount); | |||
5448 | size_t I = 0; | |||
5449 | for (CoreFileMapping &Mapping : Ret.Mappings) { | |||
5450 | ++I; | |||
5451 | if (!Filenames.isValidOffsetForDataOfSize(FilenamesOffset, 1)) | |||
5452 | return createError( | |||
5453 | "unable to read the file name for the mapping with index " + | |||
5454 | Twine(I) + ": the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5455 | " is truncated"); | |||
5456 | Mapping.Start = Desc.getAddress(&DescOffset); | |||
5457 | Mapping.End = Desc.getAddress(&DescOffset); | |||
5458 | Mapping.Offset = Desc.getAddress(&DescOffset); | |||
5459 | Mapping.Filename = Filenames.getCStrRef(&FilenamesOffset); | |||
5460 | } | |||
5461 | ||||
5462 | return Ret; | |||
5463 | } | |||
5464 | ||||
5465 | template <typename ELFT> | |||
5466 | static void printCoreNote(raw_ostream &OS, const CoreNote &Note) { | |||
5467 | // Length of "0x<address>" string. | |||
5468 | const int FieldWidth = ELFT::Is64Bits ? 18 : 10; | |||
5469 | ||||
5470 | OS << " Page size: " << format_decimal(Note.PageSize, 0) << '\n'; | |||
5471 | OS << " " << right_justify("Start", FieldWidth) << " " | |||
5472 | << right_justify("End", FieldWidth) << " " | |||
5473 | << right_justify("Page Offset", FieldWidth) << '\n'; | |||
5474 | for (const CoreFileMapping &Mapping : Note.Mappings) { | |||
5475 | OS << " " << format_hex(Mapping.Start, FieldWidth) << " " | |||
5476 | << format_hex(Mapping.End, FieldWidth) << " " | |||
5477 | << format_hex(Mapping.Offset, FieldWidth) << "\n " | |||
5478 | << Mapping.Filename << '\n'; | |||
5479 | } | |||
5480 | } | |||
5481 | ||||
5482 | const NoteType GenericNoteTypes[] = { | |||
5483 | {ELF::NT_VERSION, "NT_VERSION (version)"}, | |||
5484 | {ELF::NT_ARCH, "NT_ARCH (architecture)"}, | |||
5485 | {ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN, "OPEN"}, | |||
5486 | {ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC, "func"}, | |||
5487 | }; | |||
5488 | ||||
5489 | const NoteType GNUNoteTypes[] = { | |||
5490 | {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"}, | |||
5491 | {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"}, | |||
5492 | {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"}, | |||
5493 | {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"}, | |||
5494 | {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"}, | |||
5495 | }; | |||
5496 | ||||
5497 | const NoteType FreeBSDCoreNoteTypes[] = { | |||
5498 | {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"}, | |||
5499 | {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"}, | |||
5500 | {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"}, | |||
5501 | {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"}, | |||
5502 | {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"}, | |||
5503 | {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"}, | |||
5504 | {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"}, | |||
5505 | {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"}, | |||
5506 | {ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS, | |||
5507 | "NT_PROCSTAT_PSSTRINGS (ps_strings data)"}, | |||
5508 | {ELF::NT_FREEBSD_PROCSTAT_AUXV, "NT_PROCSTAT_AUXV (auxv data)"}, | |||
5509 | }; | |||
5510 | ||||
5511 | const NoteType FreeBSDNoteTypes[] = { | |||
5512 | {ELF::NT_FREEBSD_ABI_TAG, "NT_FREEBSD_ABI_TAG (ABI version tag)"}, | |||
5513 | {ELF::NT_FREEBSD_NOINIT_TAG, "NT_FREEBSD_NOINIT_TAG (no .init tag)"}, | |||
5514 | {ELF::NT_FREEBSD_ARCH_TAG, "NT_FREEBSD_ARCH_TAG (architecture tag)"}, | |||
5515 | {ELF::NT_FREEBSD_FEATURE_CTL, | |||
5516 | "NT_FREEBSD_FEATURE_CTL (FreeBSD feature control)"}, | |||
5517 | }; | |||
5518 | ||||
5519 | const NoteType NetBSDCoreNoteTypes[] = { | |||
5520 | {ELF::NT_NETBSDCORE_PROCINFO, | |||
5521 | "NT_NETBSDCORE_PROCINFO (procinfo structure)"}, | |||
5522 | {ELF::NT_NETBSDCORE_AUXV, "NT_NETBSDCORE_AUXV (ELF auxiliary vector data)"}, | |||
5523 | {ELF::NT_NETBSDCORE_LWPSTATUS, "PT_LWPSTATUS (ptrace_lwpstatus structure)"}, | |||
5524 | }; | |||
5525 | ||||
5526 | const NoteType OpenBSDCoreNoteTypes[] = { | |||
5527 | {ELF::NT_OPENBSD_PROCINFO, "NT_OPENBSD_PROCINFO (procinfo structure)"}, | |||
5528 | {ELF::NT_OPENBSD_AUXV, "NT_OPENBSD_AUXV (ELF auxiliary vector data)"}, | |||
5529 | {ELF::NT_OPENBSD_REGS, "NT_OPENBSD_REGS (regular registers)"}, | |||
5530 | {ELF::NT_OPENBSD_FPREGS, "NT_OPENBSD_FPREGS (floating point registers)"}, | |||
5531 | {ELF::NT_OPENBSD_WCOOKIE, "NT_OPENBSD_WCOOKIE (window cookie)"}, | |||
5532 | }; | |||
5533 | ||||
5534 | const NoteType AMDNoteTypes[] = { | |||
5535 | {ELF::NT_AMD_HSA_CODE_OBJECT_VERSION, | |||
5536 | "NT_AMD_HSA_CODE_OBJECT_VERSION (AMD HSA Code Object Version)"}, | |||
5537 | {ELF::NT_AMD_HSA_HSAIL, "NT_AMD_HSA_HSAIL (AMD HSA HSAIL Properties)"}, | |||
5538 | {ELF::NT_AMD_HSA_ISA_VERSION, "NT_AMD_HSA_ISA_VERSION (AMD HSA ISA Version)"}, | |||
5539 | {ELF::NT_AMD_HSA_METADATA, "NT_AMD_HSA_METADATA (AMD HSA Metadata)"}, | |||
5540 | {ELF::NT_AMD_HSA_ISA_NAME, "NT_AMD_HSA_ISA_NAME (AMD HSA ISA Name)"}, | |||
5541 | {ELF::NT_AMD_PAL_METADATA, "NT_AMD_PAL_METADATA (AMD PAL Metadata)"}, | |||
5542 | }; | |||
5543 | ||||
5544 | const NoteType AMDGPUNoteTypes[] = { | |||
5545 | {ELF::NT_AMDGPU_METADATA, "NT_AMDGPU_METADATA (AMDGPU Metadata)"}, | |||
5546 | }; | |||
5547 | ||||
5548 | const NoteType LLVMOMPOFFLOADNoteTypes[] = { | |||
5549 | {ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION, | |||
5550 | "NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)"}, | |||
5551 | {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER, | |||
5552 | "NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)"}, | |||
5553 | {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION, | |||
5554 | "NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)"}, | |||
5555 | }; | |||
5556 | ||||
5557 | const NoteType AndroidNoteTypes[] = { | |||
5558 | {ELF::NT_ANDROID_TYPE_IDENT, "NT_ANDROID_TYPE_IDENT"}, | |||
5559 | {ELF::NT_ANDROID_TYPE_KUSER, "NT_ANDROID_TYPE_KUSER"}, | |||
5560 | {ELF::NT_ANDROID_TYPE_MEMTAG, | |||
5561 | "NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)"}, | |||
5562 | }; | |||
5563 | ||||
5564 | const NoteType CoreNoteTypes[] = { | |||
5565 | {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"}, | |||
5566 | {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"}, | |||
5567 | {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"}, | |||
5568 | {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"}, | |||
5569 | {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"}, | |||
5570 | {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"}, | |||
5571 | {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"}, | |||
5572 | {ELF::NT_PSINFO, "NT_PSINFO (psinfo structure)"}, | |||
5573 | {ELF::NT_LWPSTATUS, "NT_LWPSTATUS (lwpstatus_t structure)"}, | |||
5574 | {ELF::NT_LWPSINFO, "NT_LWPSINFO (lwpsinfo_t structure)"}, | |||
5575 | {ELF::NT_WIN32PSTATUS, "NT_WIN32PSTATUS (win32_pstatus structure)"}, | |||
5576 | ||||
5577 | {ELF::NT_PPC_VMX, "NT_PPC_VMX (ppc Altivec registers)"}, | |||
5578 | {ELF::NT_PPC_VSX, "NT_PPC_VSX (ppc VSX registers)"}, | |||
5579 | {ELF::NT_PPC_TAR, "NT_PPC_TAR (ppc TAR register)"}, | |||
5580 | {ELF::NT_PPC_PPR, "NT_PPC_PPR (ppc PPR register)"}, | |||
5581 | {ELF::NT_PPC_DSCR, "NT_PPC_DSCR (ppc DSCR register)"}, | |||
5582 | {ELF::NT_PPC_EBB, "NT_PPC_EBB (ppc EBB registers)"}, | |||
5583 | {ELF::NT_PPC_PMU, "NT_PPC_PMU (ppc PMU registers)"}, | |||
5584 | {ELF::NT_PPC_TM_CGPR, "NT_PPC_TM_CGPR (ppc checkpointed GPR registers)"}, | |||
5585 | {ELF::NT_PPC_TM_CFPR, | |||
5586 | "NT_PPC_TM_CFPR (ppc checkpointed floating point registers)"}, | |||
5587 | {ELF::NT_PPC_TM_CVMX, | |||
5588 | "NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)"}, | |||
5589 | {ELF::NT_PPC_TM_CVSX, "NT_PPC_TM_CVSX (ppc checkpointed VSX registers)"}, | |||
5590 | {ELF::NT_PPC_TM_SPR, "NT_PPC_TM_SPR (ppc TM special purpose registers)"}, | |||
5591 | {ELF::NT_PPC_TM_CTAR, "NT_PPC_TM_CTAR (ppc checkpointed TAR register)"}, | |||
5592 | {ELF::NT_PPC_TM_CPPR, "NT_PPC_TM_CPPR (ppc checkpointed PPR register)"}, | |||
5593 | {ELF::NT_PPC_TM_CDSCR, "NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)"}, | |||
5594 | ||||
5595 | {ELF::NT_386_TLS, "NT_386_TLS (x86 TLS information)"}, | |||
5596 | {ELF::NT_386_IOPERM, "NT_386_IOPERM (x86 I/O permissions)"}, | |||
5597 | {ELF::NT_X86_XSTATE, "NT_X86_XSTATE (x86 XSAVE extended state)"}, | |||
5598 | ||||
5599 | {ELF::NT_S390_HIGH_GPRS, "NT_S390_HIGH_GPRS (s390 upper register halves)"}, | |||
5600 | {ELF::NT_S390_TIMER, "NT_S390_TIMER (s390 timer register)"}, | |||
5601 | {ELF::NT_S390_TODCMP, "NT_S390_TODCMP (s390 TOD comparator register)"}, | |||
5602 | {ELF::NT_S390_TODPREG, "NT_S390_TODPREG (s390 TOD programmable register)"}, | |||
5603 | {ELF::NT_S390_CTRS, "NT_S390_CTRS (s390 control registers)"}, | |||
5604 | {ELF::NT_S390_PREFIX, "NT_S390_PREFIX (s390 prefix register)"}, | |||
5605 | {ELF::NT_S390_LAST_BREAK, | |||
5606 | "NT_S390_LAST_BREAK (s390 last breaking event address)"}, | |||
5607 | {ELF::NT_S390_SYSTEM_CALL, | |||
5608 | "NT_S390_SYSTEM_CALL (s390 system call restart data)"}, | |||
5609 | {ELF::NT_S390_TDB, "NT_S390_TDB (s390 transaction diagnostic block)"}, | |||
5610 | {ELF::NT_S390_VXRS_LOW, | |||
5611 | "NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)"}, | |||
5612 | {ELF::NT_S390_VXRS_HIGH, "NT_S390_VXRS_HIGH (s390 vector registers 16-31)"}, | |||
5613 | {ELF::NT_S390_GS_CB, "NT_S390_GS_CB (s390 guarded-storage registers)"}, | |||
5614 | {ELF::NT_S390_GS_BC, | |||
5615 | "NT_S390_GS_BC (s390 guarded-storage broadcast control)"}, | |||
5616 | ||||
5617 | {ELF::NT_ARM_VFP, "NT_ARM_VFP (arm VFP registers)"}, | |||
5618 | {ELF::NT_ARM_TLS, "NT_ARM_TLS (AArch TLS registers)"}, | |||
5619 | {ELF::NT_ARM_HW_BREAK, | |||
5620 | "NT_ARM_HW_BREAK (AArch hardware breakpoint registers)"}, | |||
5621 | {ELF::NT_ARM_HW_WATCH, | |||
5622 | "NT_ARM_HW_WATCH (AArch hardware watchpoint registers)"}, | |||
5623 | ||||
5624 | {ELF::NT_FILE, "NT_FILE (mapped files)"}, | |||
5625 | {ELF::NT_PRXFPREG, "NT_PRXFPREG (user_xfpregs structure)"}, | |||
5626 | {ELF::NT_SIGINFO, "NT_SIGINFO (siginfo_t data)"}, | |||
5627 | }; | |||
5628 | ||||
5629 | template <class ELFT> | |||
5630 | StringRef getNoteTypeName(const typename ELFT::Note &Note, unsigned ELFType) { | |||
5631 | uint32_t Type = Note.getType(); | |||
5632 | auto FindNote = [&](ArrayRef<NoteType> V) -> StringRef { | |||
5633 | for (const NoteType &N : V) | |||
5634 | if (N.ID == Type) | |||
5635 | return N.Name; | |||
5636 | return ""; | |||
5637 | }; | |||
5638 | ||||
5639 | StringRef Name = Note.getName(); | |||
5640 | if (Name == "GNU") | |||
5641 | return FindNote(GNUNoteTypes); | |||
5642 | if (Name == "FreeBSD") { | |||
5643 | if (ELFType == ELF::ET_CORE) { | |||
5644 | // FreeBSD also places the generic core notes in the FreeBSD namespace. | |||
5645 | StringRef Result = FindNote(FreeBSDCoreNoteTypes); | |||
5646 | if (!Result.empty()) | |||
5647 | return Result; | |||
5648 | return FindNote(CoreNoteTypes); | |||
5649 | } else { | |||
5650 | return FindNote(FreeBSDNoteTypes); | |||
5651 | } | |||
5652 | } | |||
5653 | if (ELFType == ELF::ET_CORE && Name.startswith("NetBSD-CORE")) { | |||
5654 | StringRef Result = FindNote(NetBSDCoreNoteTypes); | |||
5655 | if (!Result.empty()) | |||
5656 | return Result; | |||
5657 | return FindNote(CoreNoteTypes); | |||
5658 | } | |||
5659 | if (ELFType == ELF::ET_CORE && Name.startswith("OpenBSD")) { | |||
5660 | // OpenBSD also places the generic core notes in the OpenBSD namespace. | |||
5661 | StringRef Result = FindNote(OpenBSDCoreNoteTypes); | |||
5662 | if (!Result.empty()) | |||
5663 | return Result; | |||
5664 | return FindNote(CoreNoteTypes); | |||
5665 | } | |||
5666 | if (Name == "AMD") | |||
5667 | return FindNote(AMDNoteTypes); | |||
5668 | if (Name == "AMDGPU") | |||
5669 | return FindNote(AMDGPUNoteTypes); | |||
5670 | if (Name == "LLVMOMPOFFLOAD") | |||
5671 | return FindNote(LLVMOMPOFFLOADNoteTypes); | |||
5672 | if (Name == "Android") | |||
5673 | return FindNote(AndroidNoteTypes); | |||
5674 | ||||
5675 | if (ELFType == ELF::ET_CORE) | |||
5676 | return FindNote(CoreNoteTypes); | |||
5677 | return FindNote(GenericNoteTypes); | |||
5678 | } | |||
5679 | ||||
5680 | template <class ELFT> | |||
5681 | static void printNotesHelper( | |||
5682 | const ELFDumper<ELFT> &Dumper, | |||
5683 | llvm::function_ref<void(Optional<StringRef>, typename ELFT::Off, | |||
5684 | typename ELFT::Addr)> | |||
5685 | StartNotesFn, | |||
5686 | llvm::function_ref<Error(const typename ELFT::Note &, bool)> ProcessNoteFn, | |||
5687 | llvm::function_ref<void()> FinishNotesFn) { | |||
5688 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
5689 | bool IsCoreFile = Obj.getHeader().e_type == ELF::ET_CORE; | |||
5690 | ||||
5691 | ArrayRef<typename ELFT::Shdr> Sections = cantFail(Obj.sections()); | |||
5692 | if (!IsCoreFile && !Sections.empty()) { | |||
5693 | for (const typename ELFT::Shdr &S : Sections) { | |||
5694 | if (S.sh_type != SHT_NOTE) | |||
5695 | continue; | |||
5696 | StartNotesFn(expectedToOptional(Obj.getSectionName(S)), S.sh_offset, | |||
5697 | S.sh_size); | |||
5698 | Error Err = Error::success(); | |||
5699 | size_t I = 0; | |||
5700 | for (const typename ELFT::Note Note : Obj.notes(S, Err)) { | |||
5701 | if (Error E = ProcessNoteFn(Note, IsCoreFile)) | |||
5702 | Dumper.reportUniqueWarning( | |||
5703 | "unable to read note with index " + Twine(I) + " from the " + | |||
5704 | describe(Obj, S) + ": " + toString(std::move(E))); | |||
5705 | ++I; | |||
5706 | } | |||
5707 | if (Err) | |||
5708 | Dumper.reportUniqueWarning("unable to read notes from the " + | |||
5709 | describe(Obj, S) + ": " + | |||
5710 | toString(std::move(Err))); | |||
5711 | FinishNotesFn(); | |||
5712 | } | |||
5713 | return; | |||
5714 | } | |||
5715 | ||||
5716 | Expected<ArrayRef<typename ELFT::Phdr>> PhdrsOrErr = Obj.program_headers(); | |||
5717 | if (!PhdrsOrErr) { | |||
5718 | Dumper.reportUniqueWarning( | |||
5719 | "unable to read program headers to locate the PT_NOTE segment: " + | |||
5720 | toString(PhdrsOrErr.takeError())); | |||
5721 | return; | |||
5722 | } | |||
5723 | ||||
5724 | for (size_t I = 0, E = (*PhdrsOrErr).size(); I != E; ++I) { | |||
5725 | const typename ELFT::Phdr &P = (*PhdrsOrErr)[I]; | |||
5726 | if (P.p_type != PT_NOTE) | |||
5727 | continue; | |||
5728 | StartNotesFn(/*SecName=*/std::nullopt, P.p_offset, P.p_filesz); | |||
5729 | Error Err = Error::success(); | |||
5730 | size_t Index = 0; | |||
5731 | for (const typename ELFT::Note Note : Obj.notes(P, Err)) { | |||
5732 | if (Error E = ProcessNoteFn(Note, IsCoreFile)) | |||
5733 | Dumper.reportUniqueWarning("unable to read note with index " + | |||
5734 | Twine(Index) + | |||
5735 | " from the PT_NOTE segment with index " + | |||
5736 | Twine(I) + ": " + toString(std::move(E))); | |||
5737 | ++Index; | |||
5738 | } | |||
5739 | if (Err) | |||
5740 | Dumper.reportUniqueWarning( | |||
5741 | "unable to read notes from the PT_NOTE segment with index " + | |||
5742 | Twine(I) + ": " + toString(std::move(Err))); | |||
5743 | FinishNotesFn(); | |||
5744 | } | |||
5745 | } | |||
5746 | ||||
5747 | template <class ELFT> void GNUELFDumper<ELFT>::printNotes() { | |||
5748 | bool IsFirstHeader = true; | |||
5749 | auto PrintHeader = [&](Optional<StringRef> SecName, | |||
5750 | const typename ELFT::Off Offset, | |||
5751 | const typename ELFT::Addr Size) { | |||
5752 | // Print a newline between notes sections to match GNU readelf. | |||
5753 | if (!IsFirstHeader) { | |||
5754 | OS << '\n'; | |||
5755 | } else { | |||
5756 | IsFirstHeader = false; | |||
5757 | } | |||
5758 | ||||
5759 | OS << "Displaying notes found "; | |||
5760 | ||||
5761 | if (SecName) | |||
5762 | OS << "in: " << *SecName << "\n"; | |||
5763 | else | |||
5764 | OS << "at file offset " << format_hex(Offset, 10) << " with length " | |||
5765 | << format_hex(Size, 10) << ":\n"; | |||
5766 | ||||
5767 | OS << " Owner Data size \tDescription\n"; | |||
5768 | }; | |||
5769 | ||||
5770 | auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error { | |||
5771 | StringRef Name = Note.getName(); | |||
5772 | ArrayRef<uint8_t> Descriptor = Note.getDesc(); | |||
5773 | Elf_Word Type = Note.getType(); | |||
5774 | ||||
5775 | // Print the note owner/type. | |||
5776 | OS << " " << left_justify(Name, 20) << ' ' | |||
5777 | << format_hex(Descriptor.size(), 10) << '\t'; | |||
5778 | ||||
5779 | StringRef NoteType = | |||
5780 | getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type); | |||
5781 | if (!NoteType.empty()) | |||
5782 | OS << NoteType << '\n'; | |||
5783 | else | |||
5784 | OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n"; | |||
5785 | ||||
5786 | // Print the description, or fallback to printing raw bytes for unknown | |||
5787 | // owners/if we fail to pretty-print the contents. | |||
5788 | if (Name == "GNU") { | |||
5789 | if (printGNUNote<ELFT>(OS, Type, Descriptor)) | |||
5790 | return Error::success(); | |||
5791 | } else if (Name == "FreeBSD") { | |||
5792 | if (Optional<FreeBSDNote> N = | |||
5793 | getFreeBSDNote<ELFT>(Type, Descriptor, IsCore)) { | |||
5794 | OS << " " << N->Type << ": " << N->Value << '\n'; | |||
5795 | return Error::success(); | |||
5796 | } | |||
5797 | } else if (Name == "AMD") { | |||
5798 | const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); | |||
5799 | if (!N.Type.empty()) { | |||
5800 | OS << " " << N.Type << ":\n " << N.Value << '\n'; | |||
5801 | return Error::success(); | |||
5802 | } | |||
5803 | } else if (Name == "AMDGPU") { | |||
5804 | const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); | |||
5805 | if (!N.Type.empty()) { | |||
5806 | OS << " " << N.Type << ":\n " << N.Value << '\n'; | |||
5807 | return Error::success(); | |||
5808 | } | |||
5809 | } else if (Name == "LLVMOMPOFFLOAD") { | |||
5810 | if (printLLVMOMPOFFLOADNote<ELFT>(OS, Type, Descriptor)) | |||
5811 | return Error::success(); | |||
5812 | } else if (Name == "CORE") { | |||
5813 | if (Type == ELF::NT_FILE) { | |||
5814 | DataExtractor DescExtractor(Descriptor, | |||
5815 | ELFT::TargetEndianness == support::little, | |||
5816 | sizeof(Elf_Addr)); | |||
5817 | if (Expected<CoreNote> NoteOrErr = readCoreNote(DescExtractor)) { | |||
5818 | printCoreNote<ELFT>(OS, *NoteOrErr); | |||
5819 | return Error::success(); | |||
5820 | } else { | |||
5821 | return NoteOrErr.takeError(); | |||
5822 | } | |||
5823 | } | |||
5824 | } else if (Name == "Android") { | |||
5825 | if (printAndroidNote(OS, Type, Descriptor)) | |||
5826 | return Error::success(); | |||
5827 | } | |||
5828 | if (!Descriptor.empty()) { | |||
5829 | OS << " description data:"; | |||
5830 | for (uint8_t B : Descriptor) | |||
5831 | OS << " " << format("%02x", B); | |||
5832 | OS << '\n'; | |||
5833 | } | |||
5834 | return Error::success(); | |||
5835 | }; | |||
5836 | ||||
5837 | printNotesHelper(*this, PrintHeader, ProcessNote, []() {}); | |||
5838 | } | |||
5839 | ||||
5840 | template <class ELFT> void GNUELFDumper<ELFT>::printELFLinkerOptions() { | |||
5841 | OS << "printELFLinkerOptions not implemented!\n"; | |||
5842 | } | |||
5843 | ||||
5844 | template <class ELFT> | |||
5845 | void ELFDumper<ELFT>::printDependentLibsHelper( | |||
5846 | function_ref<void(const Elf_Shdr &)> OnSectionStart, | |||
5847 | function_ref<void(StringRef, uint64_t)> OnLibEntry) { | |||
5848 | auto Warn = [this](unsigned SecNdx, StringRef Msg) { | |||
5849 | this->reportUniqueWarning("SHT_LLVM_DEPENDENT_LIBRARIES section at index " + | |||
5850 | Twine(SecNdx) + " is broken: " + Msg); | |||
5851 | }; | |||
5852 | ||||
5853 | unsigned I = -1; | |||
5854 | for (const Elf_Shdr &Shdr : cantFail(Obj.sections())) { | |||
5855 | ++I; | |||
5856 | if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES) | |||
5857 | continue; | |||
5858 | ||||
5859 | OnSectionStart(Shdr); | |||
5860 | ||||
5861 | Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Shdr); | |||
5862 | if (!ContentsOrErr) { | |||
5863 | Warn(I, toString(ContentsOrErr.takeError())); | |||
5864 | continue; | |||
5865 | } | |||
5866 | ||||
5867 | ArrayRef<uint8_t> Contents = *ContentsOrErr; | |||
5868 | if (!Contents.empty() && Contents.back() != 0) { | |||
5869 | Warn(I, "the content is not null-terminated"); | |||
5870 | continue; | |||
5871 | } | |||
5872 | ||||
5873 | for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) { | |||
5874 | StringRef Lib((const char *)I); | |||
5875 | OnLibEntry(Lib, I - Contents.begin()); | |||
5876 | I += Lib.size() + 1; | |||
5877 | } | |||
5878 | } | |||
5879 | } | |||
5880 | ||||
5881 | template <class ELFT> | |||
5882 | void ELFDumper<ELFT>::forEachRelocationDo( | |||
5883 | const Elf_Shdr &Sec, bool RawRelr, | |||
5884 | llvm::function_ref<void(const Relocation<ELFT> &, unsigned, | |||
5885 | const Elf_Shdr &, const Elf_Shdr *)> | |||
5886 | RelRelaFn, | |||
5887 | llvm::function_ref<void(const Elf_Relr &)> RelrFn) { | |||
5888 | auto Warn = [&](Error &&E, | |||
5889 | const Twine &Prefix = "unable to read relocations from") { | |||
5890 | this->reportUniqueWarning(Prefix + " " + describe(Sec) + ": " + | |||
5891 | toString(std::move(E))); | |||
5892 | }; | |||
5893 | ||||
5894 | // SHT_RELR/SHT_ANDROID_RELR sections do not have an associated symbol table. | |||
5895 | // For them we should not treat the value of the sh_link field as an index of | |||
5896 | // a symbol table. | |||
5897 | const Elf_Shdr *SymTab; | |||
5898 | if (Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_RELR) { | |||
5899 | Expected<const Elf_Shdr *> SymTabOrErr = Obj.getSection(Sec.sh_link); | |||
5900 | if (!SymTabOrErr) { | |||
5901 | Warn(SymTabOrErr.takeError(), "unable to locate a symbol table for"); | |||
5902 | return; | |||
5903 | } | |||
5904 | SymTab = *SymTabOrErr; | |||
5905 | } | |||
5906 | ||||
5907 | unsigned RelNdx = 0; | |||
5908 | const bool IsMips64EL = this->Obj.isMips64EL(); | |||
5909 | switch (Sec.sh_type) { | |||
5910 | case ELF::SHT_REL: | |||
5911 | if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(Sec)) { | |||
5912 | for (const Elf_Rel &R : *RangeOrErr) | |||
5913 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
5914 | } else { | |||
5915 | Warn(RangeOrErr.takeError()); | |||
5916 | } | |||
5917 | break; | |||
5918 | case ELF::SHT_RELA: | |||
5919 | if (Expected<Elf_Rela_Range> RangeOrErr = Obj.relas(Sec)) { | |||
5920 | for (const Elf_Rela &R : *RangeOrErr) | |||
5921 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
5922 | } else { | |||
5923 | Warn(RangeOrErr.takeError()); | |||
5924 | } | |||
5925 | break; | |||
5926 | case ELF::SHT_RELR: | |||
5927 | case ELF::SHT_ANDROID_RELR: { | |||
5928 | Expected<Elf_Relr_Range> RangeOrErr = Obj.relrs(Sec); | |||
5929 | if (!RangeOrErr) { | |||
5930 | Warn(RangeOrErr.takeError()); | |||
5931 | break; | |||
5932 | } | |||
5933 | if (RawRelr) { | |||
5934 | for (const Elf_Relr &R : *RangeOrErr) | |||
5935 | RelrFn(R); | |||
5936 | break; | |||
5937 | } | |||
5938 | ||||
5939 | for (const Elf_Rel &R : Obj.decode_relrs(*RangeOrErr)) | |||
5940 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, | |||
5941 | /*SymTab=*/nullptr); | |||
5942 | break; | |||
5943 | } | |||
5944 | case ELF::SHT_ANDROID_REL: | |||
5945 | case ELF::SHT_ANDROID_RELA: | |||
5946 | if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj.android_relas(Sec)) { | |||
5947 | for (const Elf_Rela &R : *RelasOrErr) | |||
5948 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
| ||||
5949 | } else { | |||
5950 | Warn(RelasOrErr.takeError()); | |||
5951 | } | |||
5952 | break; | |||
5953 | } | |||
5954 | } | |||
5955 | ||||
5956 | template <class ELFT> | |||
5957 | StringRef ELFDumper<ELFT>::getPrintableSectionName(const Elf_Shdr &Sec) const { | |||
5958 | StringRef Name = "<?>"; | |||
5959 | if (Expected<StringRef> SecNameOrErr = | |||
5960 | Obj.getSectionName(Sec, this->WarningHandler)) | |||
5961 | Name = *SecNameOrErr; | |||
5962 | else | |||
5963 | this->reportUniqueWarning("unable to get the name of " + describe(Sec) + | |||
5964 | ": " + toString(SecNameOrErr.takeError())); | |||
5965 | return Name; | |||
5966 | } | |||
5967 | ||||
5968 | template <class ELFT> void GNUELFDumper<ELFT>::printDependentLibs() { | |||
5969 | bool SectionStarted = false; | |||
5970 | struct NameOffset { | |||
5971 | StringRef Name; | |||
5972 | uint64_t Offset; | |||
5973 | }; | |||
5974 | std::vector<NameOffset> SecEntries; | |||
5975 | NameOffset Current; | |||
5976 | auto PrintSection = [&]() { | |||
5977 | OS << "Dependent libraries section " << Current.Name << " at offset " | |||
5978 | << format_hex(Current.Offset, 1) << " contains " << SecEntries.size() | |||
5979 | << " entries:\n"; | |||
5980 | for (NameOffset Entry : SecEntries) | |||
5981 | OS << " [" << format("%6" PRIx64"l" "x", Entry.Offset) << "] " << Entry.Name | |||
5982 | << "\n"; | |||
5983 | OS << "\n"; | |||
5984 | SecEntries.clear(); | |||
5985 | }; | |||
5986 | ||||
5987 | auto OnSectionStart = [&](const Elf_Shdr &Shdr) { | |||
5988 | if (SectionStarted) | |||
5989 | PrintSection(); | |||
5990 | SectionStarted = true; | |||
5991 | Current.Offset = Shdr.sh_offset; | |||
5992 | Current.Name = this->getPrintableSectionName(Shdr); | |||
5993 | }; | |||
5994 | auto OnLibEntry = [&](StringRef Lib, uint64_t Offset) { | |||
5995 | SecEntries.push_back(NameOffset{Lib, Offset}); | |||
5996 | }; | |||
5997 | ||||
5998 | this->printDependentLibsHelper(OnSectionStart, OnLibEntry); | |||
5999 | if (SectionStarted) | |||
6000 | PrintSection(); | |||
6001 | } | |||
6002 | ||||
6003 | template <class ELFT> | |||
6004 | SmallVector<uint32_t> ELFDumper<ELFT>::getSymbolIndexesForFunctionAddress( | |||
6005 | uint64_t SymValue, Optional<const Elf_Shdr *> FunctionSec) { | |||
6006 | SmallVector<uint32_t> SymbolIndexes; | |||
6007 | if (!this->AddressToIndexMap) { | |||
6008 | // Populate the address to index map upon the first invocation of this | |||
6009 | // function. | |||
6010 | this->AddressToIndexMap.emplace(); | |||
6011 | if (this->DotSymtabSec) { | |||
6012 | if (Expected<Elf_Sym_Range> SymsOrError = | |||
6013 | Obj.symbols(this->DotSymtabSec)) { | |||
6014 | uint32_t Index = (uint32_t)-1; | |||
6015 | for (const Elf_Sym &Sym : *SymsOrError) { | |||
6016 | ++Index; | |||
6017 | ||||
6018 | if (Sym.st_shndx == ELF::SHN_UNDEF || Sym.getType() != ELF::STT_FUNC) | |||
6019 | continue; | |||
6020 | ||||
6021 | Expected<uint64_t> SymAddrOrErr = | |||
6022 | ObjF.toSymbolRef(this->DotSymtabSec, Index).getAddress(); | |||
6023 | if (!SymAddrOrErr) { | |||
6024 | std::string Name = this->getStaticSymbolName(Index); | |||
6025 | reportUniqueWarning("unable to get address of symbol '" + Name + | |||
6026 | "': " + toString(SymAddrOrErr.takeError())); | |||
6027 | return SymbolIndexes; | |||
6028 | } | |||
6029 | ||||
6030 | (*this->AddressToIndexMap)[*SymAddrOrErr].push_back(Index); | |||
6031 | } | |||
6032 | } else { | |||
6033 | reportUniqueWarning("unable to read the symbol table: " + | |||
6034 | toString(SymsOrError.takeError())); | |||
6035 | } | |||
6036 | } | |||
6037 | } | |||
6038 | ||||
6039 | auto Symbols = this->AddressToIndexMap->find(SymValue); | |||
6040 | if (Symbols == this->AddressToIndexMap->end()) | |||
6041 | return SymbolIndexes; | |||
6042 | ||||
6043 | for (uint32_t Index : Symbols->second) { | |||
6044 | // Check if the symbol is in the right section. FunctionSec == None | |||
6045 | // means "any section". | |||
6046 | if (FunctionSec) { | |||
6047 | const Elf_Sym &Sym = *cantFail(Obj.getSymbol(this->DotSymtabSec, Index)); | |||
6048 | if (Expected<const Elf_Shdr *> SecOrErr = | |||
6049 | Obj.getSection(Sym, this->DotSymtabSec, | |||
6050 | this->getShndxTable(this->DotSymtabSec))) { | |||
6051 | if (*FunctionSec != *SecOrErr) | |||
6052 | continue; | |||
6053 | } else { | |||
6054 | std::string Name = this->getStaticSymbolName(Index); | |||
6055 | // Note: it is impossible to trigger this error currently, it is | |||
6056 | // untested. | |||
6057 | reportUniqueWarning("unable to get section of symbol '" + Name + | |||
6058 | "': " + toString(SecOrErr.takeError())); | |||
6059 | return SymbolIndexes; | |||
6060 | } | |||
6061 | } | |||
6062 | ||||
6063 | SymbolIndexes.push_back(Index); | |||
6064 | } | |||
6065 | ||||
6066 | return SymbolIndexes; | |||
6067 | } | |||
6068 | ||||
6069 | template <class ELFT> | |||
6070 | bool ELFDumper<ELFT>::printFunctionStackSize( | |||
6071 | uint64_t SymValue, Optional<const Elf_Shdr *> FunctionSec, | |||
6072 | const Elf_Shdr &StackSizeSec, DataExtractor Data, uint64_t *Offset) { | |||
6073 | SmallVector<uint32_t> FuncSymIndexes = | |||
6074 | this->getSymbolIndexesForFunctionAddress(SymValue, FunctionSec); | |||
6075 | if (FuncSymIndexes.empty()) | |||
6076 | reportUniqueWarning( | |||
6077 | "could not identify function symbol for stack size entry in " + | |||
6078 | describe(StackSizeSec)); | |||
6079 | ||||
6080 | // Extract the size. The expectation is that Offset is pointing to the right | |||
6081 | // place, i.e. past the function address. | |||
6082 | Error Err = Error::success(); | |||
6083 | uint64_t StackSize = Data.getULEB128(Offset, &Err); | |||
6084 | if (Err) { | |||
6085 | reportUniqueWarning("could not extract a valid stack size from " + | |||
6086 | describe(StackSizeSec) + ": " + | |||
6087 | toString(std::move(Err))); | |||
6088 | return false; | |||
6089 | } | |||
6090 | ||||
6091 | if (FuncSymIndexes.empty()) { | |||
6092 | printStackSizeEntry(StackSize, {"?"}); | |||
6093 | } else { | |||
6094 | SmallVector<std::string> FuncSymNames; | |||
6095 | for (uint32_t Index : FuncSymIndexes) | |||
6096 | FuncSymNames.push_back(this->getStaticSymbolName(Index)); | |||
6097 | printStackSizeEntry(StackSize, FuncSymNames); | |||
6098 | } | |||
6099 | ||||
6100 | return true; | |||
6101 | } | |||
6102 | ||||
6103 | template <class ELFT> | |||
6104 | void GNUELFDumper<ELFT>::printStackSizeEntry(uint64_t Size, | |||
6105 | ArrayRef<std::string> FuncNames) { | |||
6106 | OS.PadToColumn(2); | |||
6107 | OS << format_decimal(Size, 11); | |||
6108 | OS.PadToColumn(18); | |||
6109 | ||||
6110 | OS << join(FuncNames.begin(), FuncNames.end(), ", ") << "\n"; | |||
6111 | } | |||
6112 | ||||
6113 | template <class ELFT> | |||
6114 | void ELFDumper<ELFT>::printStackSize(const Relocation<ELFT> &R, | |||
6115 | const Elf_Shdr &RelocSec, unsigned Ndx, | |||
6116 | const Elf_Shdr *SymTab, | |||
6117 | const Elf_Shdr *FunctionSec, | |||
6118 | const Elf_Shdr &StackSizeSec, | |||
6119 | const RelocationResolver &Resolver, | |||
6120 | DataExtractor Data) { | |||
6121 | // This function ignores potentially erroneous input, unless it is directly | |||
6122 | // related to stack size reporting. | |||
6123 | const Elf_Sym *Sym = nullptr; | |||
6124 | Expected<RelSymbol<ELFT>> TargetOrErr = this->getRelocationTarget(R, SymTab); | |||
6125 | if (!TargetOrErr) | |||
6126 | reportUniqueWarning("unable to get the target of relocation with index " + | |||
6127 | Twine(Ndx) + " in " + describe(RelocSec) + ": " + | |||
6128 | toString(TargetOrErr.takeError())); | |||
6129 | else | |||
6130 | Sym = TargetOrErr->Sym; | |||
6131 | ||||
6132 | uint64_t RelocSymValue = 0; | |||
6133 | if (Sym) { | |||
6134 | Expected<const Elf_Shdr *> SectionOrErr = | |||
6135 | this->Obj.getSection(*Sym, SymTab, this->getShndxTable(SymTab)); | |||
6136 | if (!SectionOrErr) { | |||
6137 | reportUniqueWarning( | |||
6138 | "cannot identify the section for relocation symbol '" + | |||
6139 | (*TargetOrErr).Name + "': " + toString(SectionOrErr.takeError())); | |||
6140 | } else if (*SectionOrErr != FunctionSec) { | |||
6141 | reportUniqueWarning("relocation symbol '" + (*TargetOrErr).Name + | |||
6142 | "' is not in the expected section"); | |||
6143 | // Pretend that the symbol is in the correct section and report its | |||
6144 | // stack size anyway. | |||
6145 | FunctionSec = *SectionOrErr; | |||
6146 | } | |||
6147 | ||||
6148 | RelocSymValue = Sym->st_value; | |||
6149 | } | |||
6150 | ||||
6151 | uint64_t Offset = R.Offset; | |||
6152 | if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { | |||
6153 | reportUniqueWarning("found invalid relocation offset (0x" + | |||
6154 | Twine::utohexstr(Offset) + ") into " + | |||
6155 | describe(StackSizeSec) + | |||
6156 | " while trying to extract a stack size entry"); | |||
6157 | return; | |||
6158 | } | |||
6159 | ||||
6160 | uint64_t SymValue = Resolver(R.Type, Offset, RelocSymValue, | |||
6161 | Data.getAddress(&Offset), R.Addend.value_or(0)); | |||
6162 | this->printFunctionStackSize(SymValue, FunctionSec, StackSizeSec, Data, | |||
6163 | &Offset); | |||
6164 | } | |||
6165 | ||||
6166 | template <class ELFT> | |||
6167 | void ELFDumper<ELFT>::printNonRelocatableStackSizes( | |||
6168 | std::function<void()> PrintHeader) { | |||
6169 | // This function ignores potentially erroneous input, unless it is directly | |||
6170 | // related to stack size reporting. | |||
6171 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
6172 | if (this->getPrintableSectionName(Sec) != ".stack_sizes") | |||
6173 | continue; | |||
6174 | PrintHeader(); | |||
6175 | ArrayRef<uint8_t> Contents = | |||
6176 | unwrapOrError(this->FileName, Obj.getSectionContents(Sec)); | |||
6177 | DataExtractor Data(Contents, Obj.isLE(), sizeof(Elf_Addr)); | |||
6178 | uint64_t Offset = 0; | |||
6179 | while (Offset < Contents.size()) { | |||
6180 | // The function address is followed by a ULEB representing the stack | |||
6181 | // size. Check for an extra byte before we try to process the entry. | |||
6182 | if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { | |||
6183 | reportUniqueWarning( | |||
6184 | describe(Sec) + | |||
6185 | " ended while trying to extract a stack size entry"); | |||
6186 | break; | |||
6187 | } | |||
6188 | uint64_t SymValue = Data.getAddress(&Offset); | |||
6189 | if (!printFunctionStackSize(SymValue, /*FunctionSec=*/std::nullopt, Sec, | |||
6190 | Data, &Offset)) | |||
6191 | break; | |||
6192 | } | |||
6193 | } | |||
6194 | } | |||
6195 | ||||
6196 | template <class ELFT> | |||
6197 | void ELFDumper<ELFT>::getSectionAndRelocations( | |||
6198 | std::function<bool(const Elf_Shdr &)> IsMatch, | |||
6199 | llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap) { | |||
6200 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
6201 | if (IsMatch(Sec)) | |||
6202 | if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr)) | |||
6203 | .second) | |||
6204 | continue; | |||
6205 | ||||
6206 | if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL) | |||
6207 | continue; | |||
6208 | ||||
6209 | Expected<const Elf_Shdr *> RelSecOrErr = Obj.getSection(Sec.sh_info); | |||
6210 | if (!RelSecOrErr) { | |||
6211 | reportUniqueWarning(describe(Sec) + | |||
6212 | ": failed to get a relocated section: " + | |||
6213 | toString(RelSecOrErr.takeError())); | |||
6214 | continue; | |||
6215 | } | |||
6216 | const Elf_Shdr *ContentsSec = *RelSecOrErr; | |||
6217 | if (IsMatch(*ContentsSec)) | |||
6218 | SecToRelocMap[ContentsSec] = &Sec; | |||
6219 | } | |||
6220 | } | |||
6221 | ||||
6222 | template <class ELFT> | |||
6223 | void ELFDumper<ELFT>::printRelocatableStackSizes( | |||
6224 | std::function<void()> PrintHeader) { | |||
6225 | // Build a map between stack size sections and their corresponding relocation | |||
6226 | // sections. | |||
6227 | llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> StackSizeRelocMap; | |||
6228 | auto IsMatch = [&](const Elf_Shdr &Sec) -> bool { | |||
6229 | StringRef SectionName; | |||
6230 | if (Expected<StringRef> NameOrErr = Obj.getSectionName(Sec)) | |||
6231 | SectionName = *NameOrErr; | |||
6232 | else | |||
6233 | consumeError(NameOrErr.takeError()); | |||
6234 | ||||
6235 | return SectionName == ".stack_sizes"; | |||
6236 | }; | |||
6237 | getSectionAndRelocations(IsMatch, StackSizeRelocMap); | |||
6238 | ||||
6239 | for (const auto &StackSizeMapEntry : StackSizeRelocMap) { | |||
6240 | PrintHeader(); | |||
6241 | const Elf_Shdr *StackSizesELFSec = StackSizeMapEntry.first; | |||
6242 | const Elf_Shdr *RelocSec = StackSizeMapEntry.second; | |||
6243 | ||||
6244 | // Warn about stack size sections without a relocation section. | |||
6245 | if (!RelocSec) { | |||
6246 | reportWarning(createError(".stack_sizes (" + describe(*StackSizesELFSec) + | |||
6247 | ") does not have a corresponding " | |||
6248 | "relocation section"), | |||
6249 | FileName); | |||
6250 | continue; | |||
6251 | } | |||
6252 | ||||
6253 | // A .stack_sizes section header's sh_link field is supposed to point | |||
6254 | // to the section that contains the functions whose stack sizes are | |||
6255 | // described in it. | |||
6256 | const Elf_Shdr *FunctionSec = unwrapOrError( | |||
6257 | this->FileName, Obj.getSection(StackSizesELFSec->sh_link)); | |||
6258 | ||||
6259 | SupportsRelocation IsSupportedFn; | |||
6260 | RelocationResolver Resolver; | |||
6261 | std::tie(IsSupportedFn, Resolver) = getRelocationResolver(this->ObjF); | |||
6262 | ArrayRef<uint8_t> Contents = | |||
6263 | unwrapOrError(this->FileName, Obj.getSectionContents(*StackSizesELFSec)); | |||
6264 | DataExtractor Data(Contents, Obj.isLE(), sizeof(Elf_Addr)); | |||
6265 | ||||
6266 | forEachRelocationDo( | |||
6267 | *RelocSec, /*RawRelr=*/false, | |||
6268 | [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec, | |||
6269 | const Elf_Shdr *SymTab) { | |||
6270 | if (!IsSupportedFn || !IsSupportedFn(R.Type)) { | |||
6271 | reportUniqueWarning( | |||
6272 | describe(*RelocSec) + | |||
6273 | " contains an unsupported relocation with index " + Twine(Ndx) + | |||
6274 | ": " + Obj.getRelocationTypeName(R.Type)); | |||
6275 | return; | |||
6276 | } | |||
6277 | ||||
6278 | this->printStackSize(R, *RelocSec, Ndx, SymTab, FunctionSec, | |||
6279 | *StackSizesELFSec, Resolver, Data); | |||
6280 | }, | |||
6281 | [](const Elf_Relr &) { | |||
6282 | llvm_unreachable("can't get here, because we only support "::llvm::llvm_unreachable_internal("can't get here, because we only support " "SHT_REL/SHT_RELA sections", "llvm/tools/llvm-readobj/ELFDumper.cpp" , 6283) | |||
6283 | "SHT_REL/SHT_RELA sections")::llvm::llvm_unreachable_internal("can't get here, because we only support " "SHT_REL/SHT_RELA sections", "llvm/tools/llvm-readobj/ELFDumper.cpp" , 6283); | |||
6284 | }); | |||
6285 | } | |||
6286 | } | |||
6287 | ||||
6288 | template <class ELFT> | |||
6289 | void GNUELFDumper<ELFT>::printStackSizes() { | |||
6290 | bool HeaderHasBeenPrinted = false; | |||
6291 | auto PrintHeader = [&]() { | |||
6292 | if (HeaderHasBeenPrinted) | |||
6293 | return; | |||
6294 | OS << "\nStack Sizes:\n"; | |||
6295 | OS.PadToColumn(9); | |||
6296 | OS << "Size"; | |||
6297 | OS.PadToColumn(18); | |||
6298 | OS << "Functions\n"; | |||
6299 | HeaderHasBeenPrinted = true; | |||
6300 | }; | |||
6301 | ||||
6302 | // For non-relocatable objects, look directly for sections whose name starts | |||
6303 | // with .stack_sizes and process the contents. | |||
6304 | if (this->Obj.getHeader().e_type == ELF::ET_REL) | |||
6305 | this->printRelocatableStackSizes(PrintHeader); | |||
6306 | else | |||
6307 | this->printNonRelocatableStackSizes(PrintHeader); | |||
6308 | } | |||
6309 | ||||
6310 | template <class ELFT> | |||
6311 | void GNUELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { | |||
6312 | size_t Bias = ELFT::Is64Bits ? 8 : 0; | |||
6313 | auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { | |||
6314 | OS.PadToColumn(2); | |||
6315 | OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias); | |||
6316 | OS.PadToColumn(11 + Bias); | |||
6317 | OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)"; | |||
6318 | OS.PadToColumn(22 + Bias); | |||
6319 | OS << format_hex_no_prefix(*E, 8 + Bias); | |||
6320 | OS.PadToColumn(31 + 2 * Bias); | |||
6321 | OS << Purpose << "\n"; | |||
6322 | }; | |||
6323 | ||||
6324 | OS << (Parser.IsStatic ? "Static GOT:\n" : "Primary GOT:\n"); | |||
6325 | OS << " Canonical gp value: " | |||
6326 | << format_hex_no_prefix(Parser.getGp(), 8 + Bias) << "\n\n"; | |||
6327 | ||||
6328 | OS << " Reserved entries:\n"; | |||
6329 | if (ELFT::Is64Bits) | |||
6330 | OS << " Address Access Initial Purpose\n"; | |||
6331 | else | |||
6332 | OS << " Address Access Initial Purpose\n"; | |||
6333 | PrintEntry(Parser.getGotLazyResolver(), "Lazy resolver"); | |||
6334 | if (Parser.getGotModulePointer()) | |||
6335 | PrintEntry(Parser.getGotModulePointer(), "Module pointer (GNU extension)"); | |||
6336 | ||||
6337 | if (!Parser.getLocalEntries().empty()) { | |||
6338 | OS << "\n"; | |||
6339 | OS << " Local entries:\n"; | |||
6340 | if (ELFT::Is64Bits) | |||
6341 | OS << " Address Access Initial\n"; | |||
6342 | else | |||
6343 | OS << " Address Access Initial\n"; | |||
6344 | for (auto &E : Parser.getLocalEntries()) | |||
6345 | PrintEntry(&E, ""); | |||
6346 | } | |||
6347 | ||||
6348 | if (Parser.IsStatic) | |||
6349 | return; | |||
6350 | ||||
6351 | if (!Parser.getGlobalEntries().empty()) { | |||
6352 | OS << "\n"; | |||
6353 | OS << " Global entries:\n"; | |||
6354 | if (ELFT::Is64Bits) | |||
6355 | OS << " Address Access Initial Sym.Val." | |||
6356 | << " Type Ndx Name\n"; | |||
6357 | else | |||
6358 | OS << " Address Access Initial Sym.Val. Type Ndx Name\n"; | |||
6359 | ||||
6360 | DataRegion<Elf_Word> ShndxTable( | |||
6361 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
6362 | for (auto &E : Parser.getGlobalEntries()) { | |||
6363 | const Elf_Sym &Sym = *Parser.getGotSym(&E); | |||
6364 | const Elf_Sym &FirstSym = this->dynamic_symbols()[0]; | |||
6365 | std::string SymName = this->getFullSymbolName( | |||
6366 | Sym, &Sym - &FirstSym, ShndxTable, this->DynamicStringTable, false); | |||
6367 | ||||
6368 | OS.PadToColumn(2); | |||
6369 | OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias)); | |||
6370 | OS.PadToColumn(11 + Bias); | |||
6371 | OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)"; | |||
6372 | OS.PadToColumn(22 + Bias); | |||
6373 | OS << to_string(format_hex_no_prefix(E, 8 + Bias)); | |||
6374 | OS.PadToColumn(31 + 2 * Bias); | |||
6375 | OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); | |||
6376 | OS.PadToColumn(40 + 3 * Bias); | |||
6377 | OS << enumToString(Sym.getType(), makeArrayRef(ElfSymbolTypes)); | |||
6378 | OS.PadToColumn(48 + 3 * Bias); | |||
6379 | OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), | |||
6380 | ShndxTable); | |||
6381 | OS.PadToColumn(52 + 3 * Bias); | |||
6382 | OS << SymName << "\n"; | |||
6383 | } | |||
6384 | } | |||
6385 | ||||
6386 | if (!Parser.getOtherEntries().empty()) | |||
6387 | OS << "\n Number of TLS and multi-GOT entries " | |||
6388 | << Parser.getOtherEntries().size() << "\n"; | |||
6389 | } | |||
6390 | ||||
6391 | template <class ELFT> | |||
6392 | void GNUELFDumper<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { | |||
6393 | size_t Bias = ELFT::Is64Bits ? 8 : 0; | |||
6394 | auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { | |||
6395 | OS.PadToColumn(2); | |||
6396 | OS << format_hex_no_prefix(Parser.getPltAddress(E), 8 + Bias); | |||
6397 | OS.PadToColumn(11 + Bias); | |||
6398 | OS << format_hex_no_prefix(*E, 8 + Bias); | |||
6399 | OS.PadToColumn(20 + 2 * Bias); | |||
6400 | OS << Purpose << "\n"; | |||
6401 | }; | |||
6402 | ||||
6403 | OS << "PLT GOT:\n\n"; | |||
6404 | ||||
6405 | OS << " Reserved entries:\n"; | |||
6406 | OS << " Address Initial Purpose\n"; | |||
6407 | PrintEntry(Parser.getPltLazyResolver(), "PLT lazy resolver"); | |||
6408 | if (Parser.getPltModulePointer()) | |||
6409 | PrintEntry(Parser.getPltModulePointer(), "Module pointer"); | |||
6410 | ||||
6411 | if (!Parser.getPltEntries().empty()) { | |||
6412 | OS << "\n"; | |||
6413 | OS << " Entries:\n"; | |||
6414 | OS << " Address Initial Sym.Val. Type Ndx Name\n"; | |||
6415 | DataRegion<Elf_Word> ShndxTable( | |||
6416 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
6417 | for (auto &E : Parser.getPltEntries()) { | |||
6418 | const Elf_Sym &Sym = *Parser.getPltSym(&E); | |||
6419 | const Elf_Sym &FirstSym = *cantFail( | |||
6420 | this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0)); | |||
6421 | std::string SymName = this->getFullSymbolName( | |||
6422 | Sym, &Sym - &FirstSym, ShndxTable, this->DynamicStringTable, false); | |||
6423 | ||||
6424 | OS.PadToColumn(2); | |||
6425 | OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias)); | |||
6426 | OS.PadToColumn(11 + Bias); | |||
6427 | OS << to_string(format_hex_no_prefix(E, 8 + Bias)); | |||
6428 | OS.PadToColumn(20 + 2 * Bias); | |||
6429 | OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); | |||
6430 | OS.PadToColumn(29 + 3 * Bias); | |||
6431 | OS << enumToString(Sym.getType(), makeArrayRef(ElfSymbolTypes)); | |||
6432 | OS.PadToColumn(37 + 3 * Bias); | |||
6433 | OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), | |||
6434 | ShndxTable); | |||
6435 | OS.PadToColumn(41 + 3 * Bias); | |||
6436 | OS << SymName << "\n"; | |||
6437 | } | |||
6438 | } | |||
6439 | } | |||
6440 | ||||
6441 | template <class ELFT> | |||
6442 | Expected<const Elf_Mips_ABIFlags<ELFT> *> | |||
6443 | getMipsAbiFlagsSection(const ELFDumper<ELFT> &Dumper) { | |||
6444 | const typename ELFT::Shdr *Sec = Dumper.findSectionByName(".MIPS.abiflags"); | |||
6445 | if (Sec == nullptr) | |||
6446 | return nullptr; | |||
6447 | ||||
6448 | constexpr StringRef ErrPrefix = "unable to read the .MIPS.abiflags section: "; | |||
6449 | Expected<ArrayRef<uint8_t>> DataOrErr = | |||
6450 | Dumper.getElfObject().getELFFile().getSectionContents(*Sec); | |||
6451 | if (!DataOrErr) | |||
6452 | return createError(ErrPrefix + toString(DataOrErr.takeError())); | |||
6453 | ||||
6454 | if (DataOrErr->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) | |||
6455 | return createError(ErrPrefix + "it has a wrong size (" + | |||
6456 | Twine(DataOrErr->size()) + ")"); | |||
6457 | return reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(DataOrErr->data()); | |||
6458 | } | |||
6459 | ||||
6460 | template <class ELFT> void GNUELFDumper<ELFT>::printMipsABIFlags() { | |||
6461 | const Elf_Mips_ABIFlags<ELFT> *Flags = nullptr; | |||
6462 | if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = | |||
6463 | getMipsAbiFlagsSection(*this)) | |||
6464 | Flags = *SecOrErr; | |||
6465 | else | |||
6466 | this->reportUniqueWarning(SecOrErr.takeError()); | |||
6467 | if (!Flags) | |||
6468 | return; | |||
6469 | ||||
6470 | OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n"; | |||
6471 | OS << "ISA: MIPS" << int(Flags->isa_level); | |||
6472 | if (Flags->isa_rev > 1) | |||
6473 | OS << "r" << int(Flags->isa_rev); | |||
6474 | OS << "\n"; | |||
6475 | OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n"; | |||
6476 | OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n"; | |||
6477 | OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n"; | |||
6478 | OS << "FP ABI: " | |||
6479 | << enumToString(Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)) << "\n"; | |||
6480 | OS << "ISA Extension: " | |||
6481 | << enumToString(Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)) << "\n"; | |||
6482 | if (Flags->ases == 0) | |||
6483 | OS << "ASEs: None\n"; | |||
6484 | else | |||
6485 | // FIXME: Print each flag on a separate line. | |||
6486 | OS << "ASEs: " << printFlags(Flags->ases, makeArrayRef(ElfMipsASEFlags)) | |||
6487 | << "\n"; | |||
6488 | OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n"; | |||
6489 | OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n"; | |||
6490 | OS << "\n"; | |||
6491 | } | |||
6492 | ||||
6493 | template <class ELFT> void LLVMELFDumper<ELFT>::printFileHeaders() { | |||
6494 | const Elf_Ehdr &E = this->Obj.getHeader(); | |||
6495 | { | |||
6496 | DictScope D(W, "ElfHeader"); | |||
6497 | { | |||
6498 | DictScope D(W, "Ident"); | |||
6499 | W.printBinary("Magic", makeArrayRef(E.e_ident).slice(ELF::EI_MAG0, 4)); | |||
6500 | W.printEnum("Class", E.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); | |||
6501 | W.printEnum("DataEncoding", E.e_ident[ELF::EI_DATA], | |||
6502 | makeArrayRef(ElfDataEncoding)); | |||
6503 | W.printNumber("FileVersion", E.e_ident[ELF::EI_VERSION]); | |||
6504 | ||||
6505 | auto OSABI = makeArrayRef(ElfOSABI); | |||
6506 | if (E.e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH && | |||
6507 | E.e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) { | |||
6508 | switch (E.e_machine) { | |||
6509 | case ELF::EM_AMDGPU: | |||
6510 | OSABI = makeArrayRef(AMDGPUElfOSABI); | |||
6511 | break; | |||
6512 | case ELF::EM_ARM: | |||
6513 | OSABI = makeArrayRef(ARMElfOSABI); | |||
6514 | break; | |||
6515 | case ELF::EM_TI_C6000: | |||
6516 | OSABI = makeArrayRef(C6000ElfOSABI); | |||
6517 | break; | |||
6518 | } | |||
6519 | } | |||
6520 | W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI); | |||
6521 | W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]); | |||
6522 | W.printBinary("Unused", makeArrayRef(E.e_ident).slice(ELF::EI_PAD)); | |||
6523 | } | |||
6524 | ||||
6525 | std::string TypeStr; | |||
6526 | if (const EnumEntry<unsigned> *Ent = getObjectFileEnumEntry(E.e_type)) { | |||
6527 | TypeStr = Ent->Name.str(); | |||
6528 | } else { | |||
6529 | if (E.e_type >= ET_LOPROC) | |||
6530 | TypeStr = "Processor Specific"; | |||
6531 | else if (E.e_type >= ET_LOOS) | |||
6532 | TypeStr = "OS Specific"; | |||
6533 | else | |||
6534 | TypeStr = "Unknown"; | |||
6535 | } | |||
6536 | W.printString("Type", TypeStr + " (0x" + utohexstr(E.e_type) + ")"); | |||
6537 | ||||
6538 | W.printEnum("Machine", E.e_machine, makeArrayRef(ElfMachineType)); | |||
6539 | W.printNumber("Version", E.e_version); | |||
6540 | W.printHex("Entry", E.e_entry); | |||
6541 | W.printHex("ProgramHeaderOffset", E.e_phoff); | |||
6542 | W.printHex("SectionHeaderOffset", E.e_shoff); | |||
6543 | if (E.e_machine == EM_MIPS) | |||
6544 | W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderMipsFlags), | |||
6545 | unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), | |||
6546 | unsigned(ELF::EF_MIPS_MACH)); | |||
6547 | else if (E.e_machine == EM_AMDGPU) { | |||
6548 | switch (E.e_ident[ELF::EI_ABIVERSION]) { | |||
6549 | default: | |||
6550 | W.printHex("Flags", E.e_flags); | |||
6551 | break; | |||
6552 | case 0: | |||
6553 | // ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags. | |||
6554 | [[fallthrough]]; | |||
6555 | case ELF::ELFABIVERSION_AMDGPU_HSA_V3: | |||
6556 | W.printFlags("Flags", E.e_flags, | |||
6557 | makeArrayRef(ElfHeaderAMDGPUFlagsABIVersion3), | |||
6558 | unsigned(ELF::EF_AMDGPU_MACH)); | |||
6559 | break; | |||
6560 | case ELF::ELFABIVERSION_AMDGPU_HSA_V4: | |||
6561 | case ELF::ELFABIVERSION_AMDGPU_HSA_V5: | |||
6562 | W.printFlags("Flags", E.e_flags, | |||
6563 | makeArrayRef(ElfHeaderAMDGPUFlagsABIVersion4), | |||
6564 | unsigned(ELF::EF_AMDGPU_MACH), | |||
6565 | unsigned(ELF::EF_AMDGPU_FEATURE_XNACK_V4), | |||
6566 | unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4)); | |||
6567 | break; | |||
6568 | } | |||
6569 | } else if (E.e_machine == EM_RISCV) | |||
6570 | W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderRISCVFlags)); | |||
6571 | else if (E.e_machine == EM_AVR) | |||
6572 | W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderAVRFlags), | |||
6573 | unsigned(ELF::EF_AVR_ARCH_MASK)); | |||
6574 | else if (E.e_machine == EM_LOONGARCH) | |||
6575 | W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderLoongArchFlags), | |||
6576 | unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), | |||
6577 | unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); | |||
6578 | else | |||
6579 | W.printFlags("Flags", E.e_flags); | |||
6580 | W.printNumber("HeaderSize", E.e_ehsize); | |||
6581 | W.printNumber("ProgramHeaderEntrySize", E.e_phentsize); | |||
6582 | W.printNumber("ProgramHeaderCount", E.e_phnum); | |||
6583 | W.printNumber("SectionHeaderEntrySize", E.e_shentsize); | |||
6584 | W.printString("SectionHeaderCount", | |||
6585 | getSectionHeadersNumString(this->Obj, this->FileName)); | |||
6586 | W.printString("StringTableSectionIndex", | |||
6587 | getSectionHeaderTableIndexString(this->Obj, this->FileName)); | |||
6588 | } | |||
6589 | } | |||
6590 | ||||
6591 | template <class ELFT> void LLVMELFDumper<ELFT>::printGroupSections() { | |||
6592 | DictScope Lists(W, "Groups"); | |||
6593 | std::vector<GroupSection> V = this->getGroups(); | |||
6594 | DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); | |||
6595 | for (const GroupSection &G : V) { | |||
6596 | DictScope D(W, "Group"); | |||
6597 | W.printNumber("Name", G.Name, G.ShName); | |||
6598 | W.printNumber("Index", G.Index); | |||
6599 | W.printNumber("Link", G.Link); | |||
6600 | W.printNumber("Info", G.Info); | |||
6601 | W.printHex("Type", getGroupType(G.Type), G.Type); | |||
6602 | W.startLine() << "Signature: " << G.Signature << "\n"; | |||
6603 | ||||
6604 | ListScope L(W, "Section(s) in group"); | |||
6605 | for (const GroupMember &GM : G.Members) { | |||
6606 | const GroupSection *MainGroup = Map[GM.Index]; | |||
6607 | if (MainGroup != &G) | |||
6608 | this->reportUniqueWarning( | |||
6609 | "section with index " + Twine(GM.Index) + | |||
6610 | ", included in the group section with index " + | |||
6611 | Twine(MainGroup->Index) + | |||
6612 | ", was also found in the group section with index " + | |||
6613 | Twine(G.Index)); | |||
6614 | W.startLine() << GM.Name << " (" << GM.Index << ")\n"; | |||
6615 | } | |||
6616 | } | |||
6617 | ||||
6618 | if (V.empty()) | |||
6619 | W.startLine() << "There are no group sections in the file.\n"; | |||
6620 | } | |||
6621 | ||||
6622 | template <class ELFT> void LLVMELFDumper<ELFT>::printRelocations() { | |||
6623 | ListScope D(W, "Relocations"); | |||
6624 | ||||
6625 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
| ||||
6626 | if (!isRelocationSec<ELFT>(Sec)) | |||
6627 | continue; | |||
6628 | ||||
6629 | StringRef Name = this->getPrintableSectionName(Sec); | |||
6630 | unsigned SecNdx = &Sec - &cantFail(this->Obj.sections()).front(); | |||
6631 | W.startLine() << "Section (" << SecNdx << ") " << Name << " {\n"; | |||
6632 | W.indent(); | |||
6633 | this->printRelocationsHelper(Sec); | |||
6634 | W.unindent(); | |||
6635 | W.startLine() << "}\n"; | |||
6636 | } | |||
6637 | } | |||
6638 | ||||
6639 | template <class ELFT> | |||
6640 | void LLVMELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) { | |||
6641 | W.startLine() << W.hex(R) << "\n"; | |||
6642 | } | |||
6643 | ||||
6644 | template <class ELFT> | |||
6645 | void LLVMELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R, | |||
6646 | const RelSymbol<ELFT> &RelSym) { | |||
6647 | StringRef SymbolName = RelSym.Name; | |||
6648 | SmallString<32> RelocName; | |||
6649 | this->Obj.getRelocationTypeName(R.Type, RelocName); | |||
6650 | ||||
6651 | if (opts::ExpandRelocs) { | |||
6652 | DictScope Group(W, "Relocation"); | |||
6653 | W.printHex("Offset", R.Offset); | |||
6654 | W.printNumber("Type", RelocName, R.Type); | |||
6655 | W.printNumber("Symbol", !SymbolName.empty() ? SymbolName : "-", R.Symbol); | |||
6656 | if (R.Addend) | |||
6657 | W.printHex("Addend", (uintX_t)*R.Addend); | |||
6658 | } else { | |||
6659 | raw_ostream &OS = W.startLine(); | |||
6660 | OS << W.hex(R.Offset) << " " << RelocName << " " | |||
6661 | << (!SymbolName.empty() ? SymbolName : "-"); | |||
6662 | if (R.Addend) | |||
6663 | OS << " " << W.hex((uintX_t)*R.Addend); | |||
6664 | OS << "\n"; | |||
6665 | } | |||
6666 | } | |||
6667 | ||||
6668 | template <class ELFT> void LLVMELFDumper<ELFT>::printSectionHeaders() { | |||
6669 | ListScope SectionsD(W, "Sections"); | |||
6670 | ||||
6671 | int SectionIndex = -1; | |||
6672 | std::vector<EnumEntry<unsigned>> FlagsList = | |||
6673 | getSectionFlagsForTarget(this->Obj.getHeader().e_ident[ELF::EI_OSABI], | |||
6674 | this->Obj.getHeader().e_machine); | |||
6675 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
6676 | DictScope SectionD(W, "Section"); | |||
6677 | W.printNumber("Index", ++SectionIndex); | |||
6678 | W.printNumber("Name", this->getPrintableSectionName(Sec), Sec.sh_name); | |||
6679 | W.printHex("Type", | |||
6680 | object::getELFSectionTypeName(this->Obj.getHeader().e_machine, | |||
6681 | Sec.sh_type), | |||
6682 | Sec.sh_type); | |||
6683 | W.printFlags("Flags", Sec.sh_flags, makeArrayRef(FlagsList)); | |||
6684 | W.printHex("Address", Sec.sh_addr); | |||
6685 | W.printHex("Offset", Sec.sh_offset); | |||
6686 | W.printNumber("Size", Sec.sh_size); | |||
6687 | W.printNumber("Link", Sec.sh_link); | |||
6688 | W.printNumber("Info", Sec.sh_info); | |||
6689 | W.printNumber("AddressAlignment", Sec.sh_addralign); | |||
6690 | W.printNumber("EntrySize", Sec.sh_entsize); | |||
6691 | ||||
6692 | if (opts::SectionRelocations) { | |||
6693 | ListScope D(W, "Relocations"); | |||
6694 | this->printRelocationsHelper(Sec); | |||
6695 | } | |||
6696 | ||||
6697 | if (opts::SectionSymbols) { | |||
6698 | ListScope D(W, "Symbols"); | |||
6699 | if (this->DotSymtabSec) { | |||
6700 | StringRef StrTable = unwrapOrError( | |||
6701 | this->FileName, | |||
6702 | this->Obj.getStringTableForSymtab(*this->DotSymtabSec)); | |||
6703 | ArrayRef<Elf_Word> ShndxTable = this->getShndxTable(this->DotSymtabSec); | |||
6704 | ||||
6705 | typename ELFT::SymRange Symbols = unwrapOrError( | |||
6706 | this->FileName, this->Obj.symbols(this->DotSymtabSec)); | |||
6707 | for (const Elf_Sym &Sym : Symbols) { | |||
6708 | const Elf_Shdr *SymSec = unwrapOrError( | |||
6709 | this->FileName, | |||
6710 | this->Obj.getSection(Sym, this->DotSymtabSec, ShndxTable)); | |||
6711 | if (SymSec == &Sec) | |||
6712 | printSymbol(Sym, &Sym - &Symbols[0], ShndxTable, StrTable, false, | |||
6713 | false); | |||
6714 | } | |||
6715 | } | |||
6716 | } | |||
6717 | ||||
6718 | if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { | |||
6719 | ArrayRef<uint8_t> Data = | |||
6720 | unwrapOrError(this->FileName, this->Obj.getSectionContents(Sec)); | |||
6721 | W.printBinaryBlock( | |||
6722 | "SectionData", | |||
6723 | StringRef(reinterpret_cast<const char *>(Data.data()), Data.size())); | |||
6724 | } | |||
6725 | } | |||
6726 | } | |||
6727 | ||||
6728 | template <class ELFT> | |||
6729 | void LLVMELFDumper<ELFT>::printSymbolSection( | |||
6730 | const Elf_Sym &Symbol, unsigned SymIndex, | |||
6731 | DataRegion<Elf_Word> ShndxTable) const { | |||
6732 | auto GetSectionSpecialType = [&]() -> Optional<StringRef> { | |||
6733 | if (Symbol.isUndefined()) | |||
6734 | return StringRef("Undefined"); | |||
6735 | if (Symbol.isProcessorSpecific()) | |||
6736 | return StringRef("Processor Specific"); | |||
6737 | if (Symbol.isOSSpecific()) | |||
6738 | return StringRef("Operating System Specific"); | |||
6739 | if (Symbol.isAbsolute()) | |||
6740 | return StringRef("Absolute"); | |||
6741 | if (Symbol.isCommon()) | |||
6742 | return StringRef("Common"); | |||
6743 | if (Symbol.isReserved() && Symbol.st_shndx != SHN_XINDEX) | |||
6744 | return StringRef("Reserved"); | |||
6745 | return std::nullopt; | |||
6746 | }; | |||
6747 | ||||
6748 | if (Optional<StringRef> Type = GetSectionSpecialType()) { | |||
6749 | W.printHex("Section", *Type, Symbol.st_shndx); | |||
6750 | return; | |||
6751 | } | |||
6752 | ||||
6753 | Expected<unsigned> SectionIndex = | |||
6754 | this->getSymbolSectionIndex(Symbol, SymIndex, ShndxTable); | |||
6755 | if (!SectionIndex) { | |||
6756 | assert(Symbol.st_shndx == SHN_XINDEX &&(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getSymbolSectionIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference" ) ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getSymbolSectionIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 6758, __extension__ __PRETTY_FUNCTION__)) | |||
6757 | "getSymbolSectionIndex should only fail due to an invalid "(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getSymbolSectionIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference" ) ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getSymbolSectionIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 6758, __extension__ __PRETTY_FUNCTION__)) | |||
6758 | "SHT_SYMTAB_SHNDX table/reference")(static_cast <bool> (Symbol.st_shndx == SHN_XINDEX && "getSymbolSectionIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference" ) ? void (0) : __assert_fail ("Symbol.st_shndx == SHN_XINDEX && \"getSymbolSectionIndex should only fail due to an invalid \" \"SHT_SYMTAB_SHNDX table/reference\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 6758, __extension__ __PRETTY_FUNCTION__)); | |||
6759 | this->reportUniqueWarning(SectionIndex.takeError()); | |||
6760 | W.printHex("Section", "Reserved", SHN_XINDEX); | |||
6761 | return; | |||
6762 | } | |||
6763 | ||||
6764 | Expected<StringRef> SectionName = | |||
6765 | this->getSymbolSectionName(Symbol, *SectionIndex); | |||
6766 | if (!SectionName) { | |||
6767 | // Don't report an invalid section name if the section headers are missing. | |||
6768 | // In such situations, all sections will be "invalid". | |||
6769 | if (!this->ObjF.sections().empty()) | |||
6770 | this->reportUniqueWarning(SectionName.takeError()); | |||
6771 | else | |||
6772 | consumeError(SectionName.takeError()); | |||
6773 | W.printHex("Section", "<?>", *SectionIndex); | |||
6774 | } else { | |||
6775 | W.printHex("Section", *SectionName, *SectionIndex); | |||
6776 | } | |||
6777 | } | |||
6778 | ||||
6779 | template <class ELFT> | |||
6780 | void LLVMELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
6781 | DataRegion<Elf_Word> ShndxTable, | |||
6782 | Optional<StringRef> StrTable, | |||
6783 | bool IsDynamic, | |||
6784 | bool /*NonVisibilityBitsUsed*/) const { | |||
6785 | std::string FullSymbolName = this->getFullSymbolName( | |||
6786 | Symbol, SymIndex, ShndxTable, StrTable, IsDynamic); | |||
6787 | unsigned char SymbolType = Symbol.getType(); | |||
6788 | ||||
6789 | DictScope D(W, "Symbol"); | |||
6790 | W.printNumber("Name", FullSymbolName, Symbol.st_name); | |||
6791 | W.printHex("Value", Symbol.st_value); | |||
6792 | W.printNumber("Size", Symbol.st_size); | |||
6793 | W.printEnum("Binding", Symbol.getBinding(), makeArrayRef(ElfSymbolBindings)); | |||
6794 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
6795 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
6796 | W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); | |||
6797 | else | |||
6798 | W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); | |||
6799 | if (Symbol.st_other == 0) | |||
6800 | // Usually st_other flag is zero. Do not pollute the output | |||
6801 | // by flags enumeration in that case. | |||
6802 | W.printNumber("Other", 0); | |||
6803 | else { | |||
6804 | std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags), | |||
6805 | std::end(ElfSymOtherFlags)); | |||
6806 | if (this->Obj.getHeader().e_machine == EM_MIPS) { | |||
6807 | // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16 | |||
6808 | // flag overlapped with other ST_MIPS_xxx flags. So consider both | |||
6809 | // cases separately. | |||
6810 | if ((Symbol.st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16) | |||
6811 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
6812 | std::begin(ElfMips16SymOtherFlags), | |||
6813 | std::end(ElfMips16SymOtherFlags)); | |||
6814 | else | |||
6815 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
6816 | std::begin(ElfMipsSymOtherFlags), | |||
6817 | std::end(ElfMipsSymOtherFlags)); | |||
6818 | } else if (this->Obj.getHeader().e_machine == EM_AARCH64) { | |||
6819 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
6820 | std::begin(ElfAArch64SymOtherFlags), | |||
6821 | std::end(ElfAArch64SymOtherFlags)); | |||
6822 | } else if (this->Obj.getHeader().e_machine == EM_RISCV) { | |||
6823 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
6824 | std::begin(ElfRISCVSymOtherFlags), | |||
6825 | std::end(ElfRISCVSymOtherFlags)); | |||
6826 | } | |||
6827 | W.printFlags("Other", Symbol.st_other, makeArrayRef(SymOtherFlags), 0x3u); | |||
6828 | } | |||
6829 | printSymbolSection(Symbol, SymIndex, ShndxTable); | |||
6830 | } | |||
6831 | ||||
6832 | template <class ELFT> | |||
6833 | void LLVMELFDumper<ELFT>::printSymbols(bool PrintSymbols, | |||
6834 | bool PrintDynamicSymbols) { | |||
6835 | if (PrintSymbols) { | |||
6836 | ListScope Group(W, "Symbols"); | |||
6837 | this->printSymbolsHelper(false); | |||
6838 | } | |||
6839 | if (PrintDynamicSymbols) { | |||
6840 | ListScope Group(W, "DynamicSymbols"); | |||
6841 | this->printSymbolsHelper(true); | |||
6842 | } | |||
6843 | } | |||
6844 | ||||
6845 | template <class ELFT> void LLVMELFDumper<ELFT>::printDynamicTable() { | |||
6846 | Elf_Dyn_Range Table = this->dynamic_table(); | |||
6847 | if (Table.empty()) | |||
6848 | return; | |||
6849 | ||||
6850 | W.startLine() << "DynamicSection [ (" << Table.size() << " entries)\n"; | |||
6851 | ||||
6852 | size_t MaxTagSize = getMaxDynamicTagSize(this->Obj, Table); | |||
6853 | // The "Name/Value" column should be indented from the "Type" column by N | |||
6854 | // spaces, where N = MaxTagSize - length of "Type" (4) + trailing | |||
6855 | // space (1) = -3. | |||
6856 | W.startLine() << " Tag" << std::string(ELFT::Is64Bits ? 16 : 8, ' ') | |||
6857 | << "Type" << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; | |||
6858 | ||||
6859 | std::string ValueFmt = "%-" + std::to_string(MaxTagSize) + "s "; | |||
6860 | for (auto Entry : Table) { | |||
6861 | uintX_t Tag = Entry.getTag(); | |||
6862 | std::string Value = this->getDynamicEntry(Tag, Entry.getVal()); | |||
6863 | W.startLine() << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10, true) | |||
6864 | << " " | |||
6865 | << format(ValueFmt.c_str(), | |||
6866 | this->Obj.getDynamicTagAsString(Tag).c_str()) | |||
6867 | << Value << "\n"; | |||
6868 | } | |||
6869 | W.startLine() << "]\n"; | |||
6870 | } | |||
6871 | ||||
6872 | template <class ELFT> void LLVMELFDumper<ELFT>::printDynamicRelocations() { | |||
6873 | W.startLine() << "Dynamic Relocations {\n"; | |||
6874 | W.indent(); | |||
6875 | this->printDynamicRelocationsHelper(); | |||
6876 | W.unindent(); | |||
6877 | W.startLine() << "}\n"; | |||
6878 | } | |||
6879 | ||||
6880 | template <class ELFT> | |||
6881 | void LLVMELFDumper<ELFT>::printProgramHeaders( | |||
6882 | bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { | |||
6883 | if (PrintProgramHeaders) | |||
6884 | printProgramHeaders(); | |||
6885 | if (PrintSectionMapping == cl::BOU_TRUE) | |||
6886 | printSectionMapping(); | |||
6887 | } | |||
6888 | ||||
6889 | template <class ELFT> void LLVMELFDumper<ELFT>::printProgramHeaders() { | |||
6890 | ListScope L(W, "ProgramHeaders"); | |||
6891 | ||||
6892 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
6893 | if (!PhdrsOrErr) { | |||
6894 | this->reportUniqueWarning("unable to dump program headers: " + | |||
6895 | toString(PhdrsOrErr.takeError())); | |||
6896 | return; | |||
6897 | } | |||
6898 | ||||
6899 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
6900 | DictScope P(W, "ProgramHeader"); | |||
6901 | StringRef Type = | |||
6902 | segmentTypeToString(this->Obj.getHeader().e_machine, Phdr.p_type); | |||
6903 | ||||
6904 | W.printHex("Type", Type.empty() ? "Unknown" : Type, Phdr.p_type); | |||
6905 | W.printHex("Offset", Phdr.p_offset); | |||
6906 | W.printHex("VirtualAddress", Phdr.p_vaddr); | |||
6907 | W.printHex("PhysicalAddress", Phdr.p_paddr); | |||
6908 | W.printNumber("FileSize", Phdr.p_filesz); | |||
6909 | W.printNumber("MemSize", Phdr.p_memsz); | |||
6910 | W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); | |||
6911 | W.printNumber("Alignment", Phdr.p_align); | |||
6912 | } | |||
6913 | } | |||
6914 | ||||
6915 | template <class ELFT> | |||
6916 | void LLVMELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) { | |||
6917 | ListScope SS(W, "VersionSymbols"); | |||
6918 | if (!Sec) | |||
6919 | return; | |||
6920 | ||||
6921 | StringRef StrTable; | |||
6922 | ArrayRef<Elf_Sym> Syms; | |||
6923 | const Elf_Shdr *SymTabSec; | |||
6924 | Expected<ArrayRef<Elf_Versym>> VerTableOrErr = | |||
6925 | this->getVersionTable(*Sec, &Syms, &StrTable, &SymTabSec); | |||
6926 | if (!VerTableOrErr) { | |||
6927 | this->reportUniqueWarning(VerTableOrErr.takeError()); | |||
6928 | return; | |||
6929 | } | |||
6930 | ||||
6931 | if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size()) | |||
6932 | return; | |||
6933 | ||||
6934 | ArrayRef<Elf_Word> ShNdxTable = this->getShndxTable(SymTabSec); | |||
6935 | for (size_t I = 0, E = Syms.size(); I < E; ++I) { | |||
6936 | DictScope S(W, "Symbol"); | |||
6937 | W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION); | |||
6938 | W.printString("Name", | |||
6939 | this->getFullSymbolName(Syms[I], I, ShNdxTable, StrTable, | |||
6940 | /*IsDynamic=*/true)); | |||
6941 | } | |||
6942 | } | |||
6943 | ||||
6944 | const EnumEntry<unsigned> SymVersionFlags[] = { | |||
6945 | {"Base", "BASE", VER_FLG_BASE}, | |||
6946 | {"Weak", "WEAK", VER_FLG_WEAK}, | |||
6947 | {"Info", "INFO", VER_FLG_INFO}}; | |||
6948 | ||||
6949 | template <class ELFT> | |||
6950 | void LLVMELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) { | |||
6951 | ListScope SD(W, "VersionDefinitions"); | |||
6952 | if (!Sec) | |||
6953 | return; | |||
6954 | ||||
6955 | Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec); | |||
6956 | if (!V) { | |||
6957 | this->reportUniqueWarning(V.takeError()); | |||
6958 | return; | |||
6959 | } | |||
6960 | ||||
6961 | for (const VerDef &D : *V) { | |||
6962 | DictScope Def(W, "Definition"); | |||
6963 | W.printNumber("Version", D.Version); | |||
6964 | W.printFlags("Flags", D.Flags, makeArrayRef(SymVersionFlags)); | |||
6965 | W.printNumber("Index", D.Ndx); | |||
6966 | W.printNumber("Hash", D.Hash); | |||
6967 | W.printString("Name", D.Name.c_str()); | |||
6968 | W.printList( | |||
6969 | "Predecessors", D.AuxV, | |||
6970 | [](raw_ostream &OS, const VerdAux &Aux) { OS << Aux.Name.c_str(); }); | |||
6971 | } | |||
6972 | } | |||
6973 | ||||
6974 | template <class ELFT> | |||
6975 | void LLVMELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) { | |||
6976 | ListScope SD(W, "VersionRequirements"); | |||
6977 | if (!Sec) | |||
6978 | return; | |||
6979 | ||||
6980 | Expected<std::vector<VerNeed>> V = | |||
6981 | this->Obj.getVersionDependencies(*Sec, this->WarningHandler); | |||
6982 | if (!V) { | |||
6983 | this->reportUniqueWarning(V.takeError()); | |||
6984 | return; | |||
6985 | } | |||
6986 | ||||
6987 | for (const VerNeed &VN : *V) { | |||
6988 | DictScope Entry(W, "Dependency"); | |||
6989 | W.printNumber("Version", VN.Version); | |||
6990 | W.printNumber("Count", VN.Cnt); | |||
6991 | W.printString("FileName", VN.File.c_str()); | |||
6992 | ||||
6993 | ListScope L(W, "Entries"); | |||
6994 | for (const VernAux &Aux : VN.AuxV) { | |||
6995 | DictScope Entry(W, "Entry"); | |||
6996 | W.printNumber("Hash", Aux.Hash); | |||
6997 | W.printFlags("Flags", Aux.Flags, makeArrayRef(SymVersionFlags)); | |||
6998 | W.printNumber("Index", Aux.Other); | |||
6999 | W.printString("Name", Aux.Name.c_str()); | |||
7000 | } | |||
7001 | } | |||
7002 | } | |||
7003 | ||||
7004 | template <class ELFT> void LLVMELFDumper<ELFT>::printHashHistograms() { | |||
7005 | W.startLine() << "Hash Histogram not implemented!\n"; | |||
7006 | } | |||
7007 | ||||
7008 | // Returns true if rel/rela section exists, and populates SymbolIndices. | |||
7009 | // Otherwise returns false. | |||
7010 | template <class ELFT> | |||
7011 | static bool getSymbolIndices(const typename ELFT::Shdr *CGRelSection, | |||
7012 | const ELFFile<ELFT> &Obj, | |||
7013 | const LLVMELFDumper<ELFT> *Dumper, | |||
7014 | SmallVector<uint32_t, 128> &SymbolIndices) { | |||
7015 | if (!CGRelSection) { | |||
7016 | Dumper->reportUniqueWarning( | |||
7017 | "relocation section for a call graph section doesn't exist"); | |||
7018 | return false; | |||
7019 | } | |||
7020 | ||||
7021 | if (CGRelSection->sh_type == SHT_REL) { | |||
7022 | typename ELFT::RelRange CGProfileRel; | |||
7023 | Expected<typename ELFT::RelRange> CGProfileRelOrError = | |||
7024 | Obj.rels(*CGRelSection); | |||
7025 | if (!CGProfileRelOrError) { | |||
7026 | Dumper->reportUniqueWarning("unable to load relocations for " | |||
7027 | "SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7028 | toString(CGProfileRelOrError.takeError())); | |||
7029 | return false; | |||
7030 | } | |||
7031 | ||||
7032 | CGProfileRel = *CGProfileRelOrError; | |||
7033 | for (const typename ELFT::Rel &Rel : CGProfileRel) | |||
7034 | SymbolIndices.push_back(Rel.getSymbol(Obj.isMips64EL())); | |||
7035 | } else { | |||
7036 | // MC unconditionally produces SHT_REL, but GNU strip/objcopy may convert | |||
7037 | // the format to SHT_RELA | |||
7038 | // (https://sourceware.org/bugzilla/show_bug.cgi?id=28035) | |||
7039 | typename ELFT::RelaRange CGProfileRela; | |||
7040 | Expected<typename ELFT::RelaRange> CGProfileRelaOrError = | |||
7041 | Obj.relas(*CGRelSection); | |||
7042 | if (!CGProfileRelaOrError) { | |||
7043 | Dumper->reportUniqueWarning("unable to load relocations for " | |||
7044 | "SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7045 | toString(CGProfileRelaOrError.takeError())); | |||
7046 | return false; | |||
7047 | } | |||
7048 | ||||
7049 | CGProfileRela = *CGProfileRelaOrError; | |||
7050 | for (const typename ELFT::Rela &Rela : CGProfileRela) | |||
7051 | SymbolIndices.push_back(Rela.getSymbol(Obj.isMips64EL())); | |||
7052 | } | |||
7053 | ||||
7054 | return true; | |||
7055 | } | |||
7056 | ||||
7057 | template <class ELFT> void LLVMELFDumper<ELFT>::printCGProfile() { | |||
7058 | llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap; | |||
7059 | ||||
7060 | auto IsMatch = [](const Elf_Shdr &Sec) -> bool { | |||
7061 | return Sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE; | |||
7062 | }; | |||
7063 | this->getSectionAndRelocations(IsMatch, SecToRelocMap); | |||
7064 | ||||
7065 | for (const auto &CGMapEntry : SecToRelocMap) { | |||
7066 | const Elf_Shdr *CGSection = CGMapEntry.first; | |||
7067 | const Elf_Shdr *CGRelSection = CGMapEntry.second; | |||
7068 | ||||
7069 | Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr = | |||
7070 | this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(*CGSection); | |||
7071 | if (!CGProfileOrErr) { | |||
7072 | this->reportUniqueWarning( | |||
7073 | "unable to load the SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7074 | toString(CGProfileOrErr.takeError())); | |||
7075 | return; | |||
7076 | } | |||
7077 | ||||
7078 | SmallVector<uint32_t, 128> SymbolIndices; | |||
7079 | bool UseReloc = | |||
7080 | getSymbolIndices<ELFT>(CGRelSection, this->Obj, this, SymbolIndices); | |||
7081 | if (UseReloc && SymbolIndices.size() != CGProfileOrErr->size() * 2) { | |||
7082 | this->reportUniqueWarning( | |||
7083 | "number of from/to pairs does not match number of frequencies"); | |||
7084 | UseReloc = false; | |||
7085 | } | |||
7086 | ||||
7087 | ListScope L(W, "CGProfile"); | |||
7088 | for (uint32_t I = 0, Size = CGProfileOrErr->size(); I != Size; ++I) { | |||
7089 | const Elf_CGProfile &CGPE = (*CGProfileOrErr)[I]; | |||
7090 | DictScope D(W, "CGProfileEntry"); | |||
7091 | if (UseReloc) { | |||
7092 | uint32_t From = SymbolIndices[I * 2]; | |||
7093 | uint32_t To = SymbolIndices[I * 2 + 1]; | |||
7094 | W.printNumber("From", this->getStaticSymbolName(From), From); | |||
7095 | W.printNumber("To", this->getStaticSymbolName(To), To); | |||
7096 | } | |||
7097 | W.printNumber("Weight", CGPE.cgp_weight); | |||
7098 | } | |||
7099 | } | |||
7100 | } | |||
7101 | ||||
7102 | template <class ELFT> void LLVMELFDumper<ELFT>::printBBAddrMaps() { | |||
7103 | bool IsRelocatable = this->Obj.getHeader().e_type == ELF::ET_REL; | |||
7104 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
7105 | if (Sec.sh_type != SHT_LLVM_BB_ADDR_MAP && | |||
7106 | Sec.sh_type != SHT_LLVM_BB_ADDR_MAP_V0) { | |||
7107 | continue; | |||
7108 | } | |||
7109 | Optional<const Elf_Shdr *> FunctionSec; | |||
7110 | if (IsRelocatable) | |||
7111 | FunctionSec = | |||
7112 | unwrapOrError(this->FileName, this->Obj.getSection(Sec.sh_link)); | |||
7113 | ListScope L(W, "BBAddrMap"); | |||
7114 | Expected<std::vector<BBAddrMap>> BBAddrMapOrErr = | |||
7115 | this->Obj.decodeBBAddrMap(Sec); | |||
7116 | if (!BBAddrMapOrErr) { | |||
7117 | this->reportUniqueWarning("unable to dump " + this->describe(Sec) + ": " + | |||
7118 | toString(BBAddrMapOrErr.takeError())); | |||
7119 | continue; | |||
7120 | } | |||
7121 | for (const BBAddrMap &AM : *BBAddrMapOrErr) { | |||
7122 | DictScope D(W, "Function"); | |||
7123 | W.printHex("At", AM.Addr); | |||
7124 | SmallVector<uint32_t> FuncSymIndex = | |||
7125 | this->getSymbolIndexesForFunctionAddress(AM.Addr, FunctionSec); | |||
7126 | std::string FuncName = "<?>"; | |||
7127 | if (FuncSymIndex.empty()) | |||
7128 | this->reportUniqueWarning( | |||
7129 | "could not identify function symbol for address (0x" + | |||
7130 | Twine::utohexstr(AM.Addr) + ") in " + this->describe(Sec)); | |||
7131 | else | |||
7132 | FuncName = this->getStaticSymbolName(FuncSymIndex.front()); | |||
7133 | W.printString("Name", FuncName); | |||
7134 | ||||
7135 | ListScope L(W, "BB entries"); | |||
7136 | for (const BBAddrMap::BBEntry &BBE : AM.BBEntries) { | |||
7137 | DictScope L(W); | |||
7138 | W.printHex("Offset", BBE.Offset); | |||
7139 | W.printHex("Size", BBE.Size); | |||
7140 | W.printBoolean("HasReturn", BBE.HasReturn); | |||
7141 | W.printBoolean("HasTailCall", BBE.HasTailCall); | |||
7142 | W.printBoolean("IsEHPad", BBE.IsEHPad); | |||
7143 | W.printBoolean("CanFallThrough", BBE.CanFallThrough); | |||
7144 | } | |||
7145 | } | |||
7146 | } | |||
7147 | } | |||
7148 | ||||
7149 | template <class ELFT> void LLVMELFDumper<ELFT>::printAddrsig() { | |||
7150 | ListScope L(W, "Addrsig"); | |||
7151 | if (!this->DotAddrsigSec) | |||
7152 | return; | |||
7153 | ||||
7154 | Expected<std::vector<uint64_t>> SymsOrErr = | |||
7155 | decodeAddrsigSection(this->Obj, *this->DotAddrsigSec); | |||
7156 | if (!SymsOrErr) { | |||
7157 | this->reportUniqueWarning(SymsOrErr.takeError()); | |||
7158 | return; | |||
7159 | } | |||
7160 | ||||
7161 | for (uint64_t Sym : *SymsOrErr) | |||
7162 | W.printNumber("Sym", this->getStaticSymbolName(Sym), Sym); | |||
7163 | } | |||
7164 | ||||
7165 | template <typename ELFT> | |||
7166 | static bool printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc, | |||
7167 | ScopedPrinter &W) { | |||
7168 | // Return true if we were able to pretty-print the note, false otherwise. | |||
7169 | switch (NoteType) { | |||
7170 | default: | |||
7171 | return false; | |||
7172 | case ELF::NT_GNU_ABI_TAG: { | |||
7173 | const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); | |||
7174 | if (!AbiTag.IsValid) { | |||
7175 | W.printString("ABI", "<corrupt GNU_ABI_TAG>"); | |||
7176 | return false; | |||
7177 | } else { | |||
7178 | W.printString("OS", AbiTag.OSName); | |||
7179 | W.printString("ABI", AbiTag.ABI); | |||
7180 | } | |||
7181 | break; | |||
7182 | } | |||
7183 | case ELF::NT_GNU_BUILD_ID: { | |||
7184 | W.printString("Build ID", getGNUBuildId(Desc)); | |||
7185 | break; | |||
7186 | } | |||
7187 | case ELF::NT_GNU_GOLD_VERSION: | |||
7188 | W.printString("Version", getDescAsStringRef(Desc)); | |||
7189 | break; | |||
7190 | case ELF::NT_GNU_PROPERTY_TYPE_0: | |||
7191 | ListScope D(W, "Property"); | |||
7192 | for (const std::string &Property : getGNUPropertyList<ELFT>(Desc)) | |||
7193 | W.printString(Property); | |||
7194 | break; | |||
7195 | } | |||
7196 | return true; | |||
7197 | } | |||
7198 | ||||
7199 | static bool printAndroidNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc, | |||
7200 | ScopedPrinter &W) { | |||
7201 | // Return true if we were able to pretty-print the note, false otherwise. | |||
7202 | AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc); | |||
7203 | if (Props.empty()) | |||
7204 | return false; | |||
7205 | for (const auto &KV : Props) | |||
7206 | W.printString(KV.first, KV.second); | |||
7207 | return true; | |||
7208 | } | |||
7209 | ||||
7210 | template <typename ELFT> | |||
7211 | static bool printLLVMOMPOFFLOADNoteLLVMStyle(uint32_t NoteType, | |||
7212 | ArrayRef<uint8_t> Desc, | |||
7213 | ScopedPrinter &W) { | |||
7214 | switch (NoteType) { | |||
7215 | default: | |||
7216 | return false; | |||
7217 | case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION: | |||
7218 | W.printString("Version", getDescAsStringRef(Desc)); | |||
7219 | break; | |||
7220 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER: | |||
7221 | W.printString("Producer", getDescAsStringRef(Desc)); | |||
7222 | break; | |||
7223 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION: | |||
7224 | W.printString("Producer version", getDescAsStringRef(Desc)); | |||
7225 | break; | |||
7226 | } | |||
7227 | return true; | |||
7228 | } | |||
7229 | ||||
7230 | static void printCoreNoteLLVMStyle(const CoreNote &Note, ScopedPrinter &W) { | |||
7231 | W.printNumber("Page Size", Note.PageSize); | |||
7232 | for (const CoreFileMapping &Mapping : Note.Mappings) { | |||
7233 | ListScope D(W, "Mapping"); | |||
7234 | W.printHex("Start", Mapping.Start); | |||
7235 | W.printHex("End", Mapping.End); | |||
7236 | W.printHex("Offset", Mapping.Offset); | |||
7237 | W.printString("Filename", Mapping.Filename); | |||
7238 | } | |||
7239 | } | |||
7240 | ||||
7241 | template <class ELFT> void LLVMELFDumper<ELFT>::printNotes() { | |||
7242 | ListScope L(W, "Notes"); | |||
7243 | ||||
7244 | std::unique_ptr<DictScope> NoteScope; | |||
7245 | auto StartNotes = [&](Optional<StringRef> SecName, | |||
7246 | const typename ELFT::Off Offset, | |||
7247 | const typename ELFT::Addr Size) { | |||
7248 | NoteScope = std::make_unique<DictScope>(W, "NoteSection"); | |||
7249 | W.printString("Name", SecName ? *SecName : "<?>"); | |||
7250 | W.printHex("Offset", Offset); | |||
7251 | W.printHex("Size", Size); | |||
7252 | }; | |||
7253 | ||||
7254 | auto EndNotes = [&] { NoteScope.reset(); }; | |||
7255 | ||||
7256 | auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error { | |||
7257 | DictScope D2(W, "Note"); | |||
7258 | StringRef Name = Note.getName(); | |||
7259 | ArrayRef<uint8_t> Descriptor = Note.getDesc(); | |||
7260 | Elf_Word Type = Note.getType(); | |||
7261 | ||||
7262 | // Print the note owner/type. | |||
7263 | W.printString("Owner", Name); | |||
7264 | W.printHex("Data size", Descriptor.size()); | |||
7265 | ||||
7266 | StringRef NoteType = | |||
7267 | getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type); | |||
7268 | if (!NoteType.empty()) | |||
7269 | W.printString("Type", NoteType); | |||
7270 | else | |||
7271 | W.printString("Type", | |||
7272 | "Unknown (" + to_string(format_hex(Type, 10)) + ")"); | |||
7273 | ||||
7274 | // Print the description, or fallback to printing raw bytes for unknown | |||
7275 | // owners/if we fail to pretty-print the contents. | |||
7276 | if (Name == "GNU") { | |||
7277 | if (printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W)) | |||
7278 | return Error::success(); | |||
7279 | } else if (Name == "FreeBSD") { | |||
7280 | if (Optional<FreeBSDNote> N = | |||
7281 | getFreeBSDNote<ELFT>(Type, Descriptor, IsCore)) { | |||
7282 | W.printString(N->Type, N->Value); | |||
7283 | return Error::success(); | |||
7284 | } | |||
7285 | } else if (Name == "AMD") { | |||
7286 | const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); | |||
7287 | if (!N.Type.empty()) { | |||
7288 | W.printString(N.Type, N.Value); | |||
7289 | return Error::success(); | |||
7290 | } | |||
7291 | } else if (Name == "AMDGPU") { | |||
7292 | const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); | |||
7293 | if (!N.Type.empty()) { | |||
7294 | W.printString(N.Type, N.Value); | |||
7295 | return Error::success(); | |||
7296 | } | |||
7297 | } else if (Name == "LLVMOMPOFFLOAD") { | |||
7298 | if (printLLVMOMPOFFLOADNoteLLVMStyle<ELFT>(Type, Descriptor, W)) | |||
7299 | return Error::success(); | |||
7300 | } else if (Name == "CORE") { | |||
7301 | if (Type == ELF::NT_FILE) { | |||
7302 | DataExtractor DescExtractor(Descriptor, | |||
7303 | ELFT::TargetEndianness == support::little, | |||
7304 | sizeof(Elf_Addr)); | |||
7305 | if (Expected<CoreNote> N = readCoreNote(DescExtractor)) { | |||
7306 | printCoreNoteLLVMStyle(*N, W); | |||
7307 | return Error::success(); | |||
7308 | } else { | |||
7309 | return N.takeError(); | |||
7310 | } | |||
7311 | } | |||
7312 | } else if (Name == "Android") { | |||
7313 | if (printAndroidNoteLLVMStyle(Type, Descriptor, W)) | |||
7314 | return Error::success(); | |||
7315 | } | |||
7316 | if (!Descriptor.empty()) { | |||
7317 | W.printBinaryBlock("Description data", Descriptor); | |||
7318 | } | |||
7319 | return Error::success(); | |||
7320 | }; | |||
7321 | ||||
7322 | printNotesHelper(*this, StartNotes, ProcessNote, EndNotes); | |||
7323 | } | |||
7324 | ||||
7325 | template <class ELFT> void LLVMELFDumper<ELFT>::printELFLinkerOptions() { | |||
7326 | ListScope L(W, "LinkerOptions"); | |||
7327 | ||||
7328 | unsigned I = -1; | |||
7329 | for (const Elf_Shdr &Shdr : cantFail(this->Obj.sections())) { | |||
7330 | ++I; | |||
7331 | if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS) | |||
7332 | continue; | |||
7333 | ||||
7334 | Expected<ArrayRef<uint8_t>> ContentsOrErr = | |||
7335 | this->Obj.getSectionContents(Shdr); | |||
7336 | if (!ContentsOrErr) { | |||
7337 | this->reportUniqueWarning("unable to read the content of the " | |||
7338 | "SHT_LLVM_LINKER_OPTIONS section: " + | |||
7339 | toString(ContentsOrErr.takeError())); | |||
7340 | continue; | |||
7341 | } | |||
7342 | if (ContentsOrErr->empty()) | |||
7343 | continue; | |||
7344 | ||||
7345 | if (ContentsOrErr->back() != 0) { | |||
7346 | this->reportUniqueWarning("SHT_LLVM_LINKER_OPTIONS section at index " + | |||
7347 | Twine(I) + | |||
7348 | " is broken: the " | |||
7349 | "content is not null-terminated"); | |||
7350 | continue; | |||
7351 | } | |||
7352 | ||||
7353 | SmallVector<StringRef, 16> Strings; | |||
7354 | toStringRef(ContentsOrErr->drop_back()).split(Strings, '\0'); | |||
7355 | if (Strings.size() % 2 != 0) { | |||
7356 | this->reportUniqueWarning( | |||
7357 | "SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + | |||
7358 | " is broken: an incomplete " | |||
7359 | "key-value pair was found. The last possible key was: \"" + | |||
7360 | Strings.back() + "\""); | |||
7361 | continue; | |||
7362 | } | |||
7363 | ||||
7364 | for (size_t I = 0; I < Strings.size(); I += 2) | |||
7365 | W.printString(Strings[I], Strings[I + 1]); | |||
7366 | } | |||
7367 | } | |||
7368 | ||||
7369 | template <class ELFT> void LLVMELFDumper<ELFT>::printDependentLibs() { | |||
7370 | ListScope L(W, "DependentLibs"); | |||
7371 | this->printDependentLibsHelper( | |||
7372 | [](const Elf_Shdr &) {}, | |||
7373 | [this](StringRef Lib, uint64_t) { W.printString(Lib); }); | |||
7374 | } | |||
7375 | ||||
7376 | template <class ELFT> void LLVMELFDumper<ELFT>::printStackSizes() { | |||
7377 | ListScope L(W, "StackSizes"); | |||
7378 | if (this->Obj.getHeader().e_type == ELF::ET_REL) | |||
7379 | this->printRelocatableStackSizes([]() {}); | |||
7380 | else | |||
7381 | this->printNonRelocatableStackSizes([]() {}); | |||
7382 | } | |||
7383 | ||||
7384 | template <class ELFT> | |||
7385 | void LLVMELFDumper<ELFT>::printStackSizeEntry(uint64_t Size, | |||
7386 | ArrayRef<std::string> FuncNames) { | |||
7387 | DictScope D(W, "Entry"); | |||
7388 | W.printList("Functions", FuncNames); | |||
7389 | W.printHex("Size", Size); | |||
7390 | } | |||
7391 | ||||
7392 | template <class ELFT> | |||
7393 | void LLVMELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { | |||
7394 | auto PrintEntry = [&](const Elf_Addr *E) { | |||
7395 | W.printHex("Address", Parser.getGotAddress(E)); | |||
7396 | W.printNumber("Access", Parser.getGotOffset(E)); | |||
7397 | W.printHex("Initial", *E); | |||
7398 | }; | |||
7399 | ||||
7400 | DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT"); | |||
7401 | ||||
7402 | W.printHex("Canonical gp value", Parser.getGp()); | |||
7403 | { | |||
7404 | ListScope RS(W, "Reserved entries"); | |||
7405 | { | |||
7406 | DictScope D(W, "Entry"); | |||
7407 | PrintEntry(Parser.getGotLazyResolver()); | |||
7408 | W.printString("Purpose", StringRef("Lazy resolver")); | |||
7409 | } | |||
7410 | ||||
7411 | if (Parser.getGotModulePointer()) { | |||
7412 | DictScope D(W, "Entry"); | |||
7413 | PrintEntry(Parser.getGotModulePointer()); | |||
7414 | W.printString("Purpose", StringRef("Module pointer (GNU extension)")); | |||
7415 | } | |||
7416 | } | |||
7417 | { | |||
7418 | ListScope LS(W, "Local entries"); | |||
7419 | for (auto &E : Parser.getLocalEntries()) { | |||
7420 | DictScope D(W, "Entry"); | |||
7421 | PrintEntry(&E); | |||
7422 | } | |||
7423 | } | |||
7424 | ||||
7425 | if (Parser.IsStatic) | |||
7426 | return; | |||
7427 | ||||
7428 | { | |||
7429 | ListScope GS(W, "Global entries"); | |||
7430 | for (auto &E : Parser.getGlobalEntries()) { | |||
7431 | DictScope D(W, "Entry"); | |||
7432 | ||||
7433 | PrintEntry(&E); | |||
7434 | ||||
7435 | const Elf_Sym &Sym = *Parser.getGotSym(&E); | |||
7436 | W.printHex("Value", Sym.st_value); | |||
7437 | W.printEnum("Type", Sym.getType(), makeArrayRef(ElfSymbolTypes)); | |||
7438 | ||||
7439 | const unsigned SymIndex = &Sym - this->dynamic_symbols().begin(); | |||
7440 | DataRegion<Elf_Word> ShndxTable( | |||
7441 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
7442 | printSymbolSection(Sym, SymIndex, ShndxTable); | |||
7443 | ||||
7444 | std::string SymName = this->getFullSymbolName( | |||
7445 | Sym, SymIndex, ShndxTable, this->DynamicStringTable, true); | |||
7446 | W.printNumber("Name", SymName, Sym.st_name); | |||
7447 | } | |||
7448 | } | |||
7449 | ||||
7450 | W.printNumber("Number of TLS and multi-GOT entries", | |||
7451 | uint64_t(Parser.getOtherEntries().size())); | |||
7452 | } | |||
7453 | ||||
7454 | template <class ELFT> | |||
7455 | void LLVMELFDumper<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { | |||
7456 | auto PrintEntry = [&](const Elf_Addr *E) { | |||
7457 | W.printHex("Address", Parser.getPltAddress(E)); | |||
7458 | W.printHex("Initial", *E); | |||
7459 | }; | |||
7460 | ||||
7461 | DictScope GS(W, "PLT GOT"); | |||
7462 | ||||
7463 | { | |||
7464 | ListScope RS(W, "Reserved entries"); | |||
7465 | { | |||
7466 | DictScope D(W, "Entry"); | |||
7467 | PrintEntry(Parser.getPltLazyResolver()); | |||
7468 | W.printString("Purpose", StringRef("PLT lazy resolver")); | |||
7469 | } | |||
7470 | ||||
7471 | if (auto E = Parser.getPltModulePointer()) { | |||
7472 | DictScope D(W, "Entry"); | |||
7473 | PrintEntry(E); | |||
7474 | W.printString("Purpose", StringRef("Module pointer")); | |||
7475 | } | |||
7476 | } | |||
7477 | { | |||
7478 | ListScope LS(W, "Entries"); | |||
7479 | DataRegion<Elf_Word> ShndxTable( | |||
7480 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
7481 | for (auto &E : Parser.getPltEntries()) { | |||
7482 | DictScope D(W, "Entry"); | |||
7483 | PrintEntry(&E); | |||
7484 | ||||
7485 | const Elf_Sym &Sym = *Parser.getPltSym(&E); | |||
7486 | W.printHex("Value", Sym.st_value); | |||
7487 | W.printEnum("Type", Sym.getType(), makeArrayRef(ElfSymbolTypes)); | |||
7488 | printSymbolSection(Sym, &Sym - this->dynamic_symbols().begin(), | |||
7489 | ShndxTable); | |||
7490 | ||||
7491 | const Elf_Sym *FirstSym = cantFail( | |||
7492 | this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0)); | |||
7493 | std::string SymName = this->getFullSymbolName( | |||
7494 | Sym, &Sym - FirstSym, ShndxTable, Parser.getPltStrTable(), true); | |||
7495 | W.printNumber("Name", SymName, Sym.st_name); | |||
7496 | } | |||
7497 | } | |||
7498 | } | |||
7499 | ||||
7500 | template <class ELFT> void LLVMELFDumper<ELFT>::printMipsABIFlags() { | |||
7501 | const Elf_Mips_ABIFlags<ELFT> *Flags; | |||
7502 | if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = | |||
7503 | getMipsAbiFlagsSection(*this)) { | |||
7504 | Flags = *SecOrErr; | |||
7505 | if (!Flags) { | |||
7506 | W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; | |||
7507 | return; | |||
7508 | } | |||
7509 | } else { | |||
7510 | this->reportUniqueWarning(SecOrErr.takeError()); | |||
7511 | return; | |||
7512 | } | |||
7513 | ||||
7514 | raw_ostream &OS = W.getOStream(); | |||
7515 | DictScope GS(W, "MIPS ABI Flags"); | |||
7516 | ||||
7517 | W.printNumber("Version", Flags->version); | |||
7518 | W.startLine() << "ISA: "; | |||
7519 | if (Flags->isa_rev <= 1) | |||
7520 | OS << format("MIPS%u", Flags->isa_level); | |||
7521 | else | |||
7522 | OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); | |||
7523 | OS << "\n"; | |||
7524 | W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)); | |||
7525 | W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags)); | |||
7526 | W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)); | |||
7527 | W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); | |||
7528 | W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); | |||
7529 | W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); | |||
7530 | W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1)); | |||
7531 | W.printHex("Flags 2", Flags->flags2); | |||
7532 | } | |||
7533 | ||||
7534 | template <class ELFT> | |||
7535 | void JSONELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
7536 | ArrayRef<std::string> InputFilenames, | |||
7537 | const Archive *A) { | |||
7538 | FileScope = std::make_unique<DictScope>(this->W); | |||
7539 | DictScope D(this->W, "FileSummary"); | |||
7540 | this->W.printString("File", FileStr); | |||
7541 | this->W.printString("Format", Obj.getFileFormatName()); | |||
7542 | this->W.printString("Arch", Triple::getArchTypeName(Obj.getArch())); | |||
7543 | this->W.printString( | |||
7544 | "AddressSize", | |||
7545 | std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress()))); | |||
7546 | this->printLoadName(); | |||
7547 | } |