File: | build/source/llvm/tools/llvm-readobj/ELFDumper.cpp |
Warning: | line 6181, 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/PointerIntPair.h" | |||
25 | #include "llvm/ADT/STLExtras.h" | |||
26 | #include "llvm/ADT/SmallString.h" | |||
27 | #include "llvm/ADT/SmallVector.h" | |||
28 | #include "llvm/ADT/StringExtras.h" | |||
29 | #include "llvm/ADT/StringRef.h" | |||
30 | #include "llvm/ADT/Twine.h" | |||
31 | #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h" | |||
32 | #include "llvm/BinaryFormat/ELF.h" | |||
33 | #include "llvm/BinaryFormat/MsgPackDocument.h" | |||
34 | #include "llvm/Demangle/Demangle.h" | |||
35 | #include "llvm/Object/Archive.h" | |||
36 | #include "llvm/Object/ELF.h" | |||
37 | #include "llvm/Object/ELFObjectFile.h" | |||
38 | #include "llvm/Object/ELFTypes.h" | |||
39 | #include "llvm/Object/Error.h" | |||
40 | #include "llvm/Object/ObjectFile.h" | |||
41 | #include "llvm/Object/RelocationResolver.h" | |||
42 | #include "llvm/Object/StackMapParser.h" | |||
43 | #include "llvm/Support/AMDGPUMetadata.h" | |||
44 | #include "llvm/Support/ARMAttributeParser.h" | |||
45 | #include "llvm/Support/ARMBuildAttributes.h" | |||
46 | #include "llvm/Support/Casting.h" | |||
47 | #include "llvm/Support/Compiler.h" | |||
48 | #include "llvm/Support/Endian.h" | |||
49 | #include "llvm/Support/ErrorHandling.h" | |||
50 | #include "llvm/Support/Format.h" | |||
51 | #include "llvm/Support/FormatVariadic.h" | |||
52 | #include "llvm/Support/FormattedStream.h" | |||
53 | #include "llvm/Support/LEB128.h" | |||
54 | #include "llvm/Support/MSP430AttributeParser.h" | |||
55 | #include "llvm/Support/MSP430Attributes.h" | |||
56 | #include "llvm/Support/MathExtras.h" | |||
57 | #include "llvm/Support/MipsABIFlags.h" | |||
58 | #include "llvm/Support/RISCVAttributeParser.h" | |||
59 | #include "llvm/Support/RISCVAttributes.h" | |||
60 | #include "llvm/Support/ScopedPrinter.h" | |||
61 | #include "llvm/Support/raw_ostream.h" | |||
62 | #include <algorithm> | |||
63 | #include <cinttypes> | |||
64 | #include <cstddef> | |||
65 | #include <cstdint> | |||
66 | #include <cstdlib> | |||
67 | #include <iterator> | |||
68 | #include <memory> | |||
69 | #include <optional> | |||
70 | #include <string> | |||
71 | #include <system_error> | |||
72 | #include <vector> | |||
73 | ||||
74 | using namespace llvm; | |||
75 | using namespace llvm::object; | |||
76 | using namespace ELF; | |||
77 | ||||
78 | #define LLVM_READOBJ_ENUM_CASE(ns, enum)case ns::enum: return "enum"; \ | |||
79 | case ns::enum: \ | |||
80 | return #enum; | |||
81 | ||||
82 | #define ENUM_ENT(enum, altName){ "enum", altName, ELF::enum } \ | |||
83 | { #enum, altName, ELF::enum } | |||
84 | ||||
85 | #define ENUM_ENT_1(enum){ "enum", "enum", ELF::enum } \ | |||
86 | { #enum, #enum, ELF::enum } | |||
87 | ||||
88 | namespace { | |||
89 | ||||
90 | template <class ELFT> struct RelSymbol { | |||
91 | RelSymbol(const typename ELFT::Sym *S, StringRef N) | |||
92 | : Sym(S), Name(N.str()) {} | |||
93 | const typename ELFT::Sym *Sym; | |||
94 | std::string Name; | |||
95 | }; | |||
96 | ||||
97 | /// Represents a contiguous uniform range in the file. We cannot just create a | |||
98 | /// range directly because when creating one of these from the .dynamic table | |||
99 | /// the size, entity size and virtual address are different entries in arbitrary | |||
100 | /// order (DT_REL, DT_RELSZ, DT_RELENT for example). | |||
101 | struct DynRegionInfo { | |||
102 | DynRegionInfo(const Binary &Owner, const ObjDumper &D) | |||
103 | : Obj(&Owner), Dumper(&D) {} | |||
104 | DynRegionInfo(const Binary &Owner, const ObjDumper &D, const uint8_t *A, | |||
105 | uint64_t S, uint64_t ES) | |||
106 | : Addr(A), Size(S), EntSize(ES), Obj(&Owner), Dumper(&D) {} | |||
107 | ||||
108 | /// Address in current address space. | |||
109 | const uint8_t *Addr = nullptr; | |||
110 | /// Size in bytes of the region. | |||
111 | uint64_t Size = 0; | |||
112 | /// Size of each entity in the region. | |||
113 | uint64_t EntSize = 0; | |||
114 | ||||
115 | /// Owner object. Used for error reporting. | |||
116 | const Binary *Obj; | |||
117 | /// Dumper used for error reporting. | |||
118 | const ObjDumper *Dumper; | |||
119 | /// Error prefix. Used for error reporting to provide more information. | |||
120 | std::string Context; | |||
121 | /// Region size name. Used for error reporting. | |||
122 | StringRef SizePrintName = "size"; | |||
123 | /// Entry size name. Used for error reporting. If this field is empty, errors | |||
124 | /// will not mention the entry size. | |||
125 | StringRef EntSizePrintName = "entry size"; | |||
126 | ||||
127 | template <typename Type> ArrayRef<Type> getAsArrayRef() const { | |||
128 | const Type *Start = reinterpret_cast<const Type *>(Addr); | |||
129 | if (!Start) | |||
130 | return {Start, Start}; | |||
131 | ||||
132 | const uint64_t Offset = | |||
133 | Addr - (const uint8_t *)Obj->getMemoryBufferRef().getBufferStart(); | |||
134 | const uint64_t ObjSize = Obj->getMemoryBufferRef().getBufferSize(); | |||
135 | ||||
136 | if (Size > ObjSize - Offset) { | |||
137 | Dumper->reportUniqueWarning( | |||
138 | "unable to read data at 0x" + Twine::utohexstr(Offset) + | |||
139 | " of size 0x" + Twine::utohexstr(Size) + " (" + SizePrintName + | |||
140 | "): it goes past the end of the file of size 0x" + | |||
141 | Twine::utohexstr(ObjSize)); | |||
142 | return {Start, Start}; | |||
143 | } | |||
144 | ||||
145 | if (EntSize == sizeof(Type) && (Size % EntSize == 0)) | |||
146 | return {Start, Start + (Size / EntSize)}; | |||
147 | ||||
148 | std::string Msg; | |||
149 | if (!Context.empty()) | |||
150 | Msg += Context + " has "; | |||
151 | ||||
152 | Msg += ("invalid " + SizePrintName + " (0x" + Twine::utohexstr(Size) + ")") | |||
153 | .str(); | |||
154 | if (!EntSizePrintName.empty()) | |||
155 | Msg += | |||
156 | (" or " + EntSizePrintName + " (0x" + Twine::utohexstr(EntSize) + ")") | |||
157 | .str(); | |||
158 | ||||
159 | Dumper->reportUniqueWarning(Msg); | |||
160 | return {Start, Start}; | |||
161 | } | |||
162 | }; | |||
163 | ||||
164 | struct GroupMember { | |||
165 | StringRef Name; | |||
166 | uint64_t Index; | |||
167 | }; | |||
168 | ||||
169 | struct GroupSection { | |||
170 | StringRef Name; | |||
171 | std::string Signature; | |||
172 | uint64_t ShName; | |||
173 | uint64_t Index; | |||
174 | uint32_t Link; | |||
175 | uint32_t Info; | |||
176 | uint32_t Type; | |||
177 | std::vector<GroupMember> Members; | |||
178 | }; | |||
179 | ||||
180 | namespace { | |||
181 | ||||
182 | struct NoteType { | |||
183 | uint32_t ID; | |||
184 | StringRef Name; | |||
185 | }; | |||
186 | ||||
187 | } // namespace | |||
188 | ||||
189 | template <class ELFT> class Relocation { | |||
190 | public: | |||
191 | Relocation(const typename ELFT::Rel &R, bool IsMips64EL) | |||
192 | : Type(R.getType(IsMips64EL)), Symbol(R.getSymbol(IsMips64EL)), | |||
193 | Offset(R.r_offset), Info(R.r_info) {} | |||
194 | ||||
195 | Relocation(const typename ELFT::Rela &R, bool IsMips64EL) | |||
196 | : Relocation((const typename ELFT::Rel &)R, IsMips64EL) { | |||
197 | Addend = R.r_addend; | |||
198 | } | |||
199 | ||||
200 | uint32_t Type; | |||
201 | uint32_t Symbol; | |||
202 | typename ELFT::uint Offset; | |||
203 | typename ELFT::uint Info; | |||
204 | std::optional<int64_t> Addend; | |||
205 | }; | |||
206 | ||||
207 | template <class ELFT> class MipsGOTParser; | |||
208 | ||||
209 | template <typename ELFT> class ELFDumper : public ObjDumper { | |||
210 | LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword ; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT ::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT:: Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash ; using Elf_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; | |||
211 | ||||
212 | public: | |||
213 | ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer); | |||
214 | ||||
215 | void printUnwindInfo() override; | |||
216 | void printNeededLibraries() override; | |||
217 | void printHashTable() override; | |||
218 | void printGnuHashTable() override; | |||
219 | void printLoadName() override; | |||
220 | void printVersionInfo() override; | |||
221 | void printArchSpecificInfo() override; | |||
222 | void printStackMap() const override; | |||
223 | void printMemtag() override; | |||
224 | ArrayRef<uint8_t> getMemtagGlobalsSectionContents(uint64_t ExpectedAddr); | |||
225 | ||||
226 | // Hash histogram shows statistics of how efficient the hash was for the | |||
227 | // dynamic symbol table. The table shows the number of hash buckets for | |||
228 | // different lengths of chains as an absolute number and percentage of the | |||
229 | // total buckets, and the cumulative coverage of symbols for each set of | |||
230 | // buckets. | |||
231 | void printHashHistograms() override; | |||
232 | ||||
233 | const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; }; | |||
234 | ||||
235 | std::string describe(const Elf_Shdr &Sec) const; | |||
236 | ||||
237 | unsigned getHashTableEntSize() const { | |||
238 | // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH | |||
239 | // sections. This violates the ELF specification. | |||
240 | if (Obj.getHeader().e_machine == ELF::EM_S390 || | |||
241 | Obj.getHeader().e_machine == ELF::EM_ALPHA) | |||
242 | return 8; | |||
243 | return 4; | |||
244 | } | |||
245 | ||||
246 | std::vector<EnumEntry<unsigned>> | |||
247 | getOtherFlagsFromSymbol(const Elf_Ehdr &Header, const Elf_Sym &Symbol) const; | |||
248 | ||||
249 | Elf_Dyn_Range dynamic_table() const { | |||
250 | // A valid .dynamic section contains an array of entries terminated | |||
251 | // with a DT_NULL entry. However, sometimes the section content may | |||
252 | // continue past the DT_NULL entry, so to dump the section correctly, | |||
253 | // we first find the end of the entries by iterating over them. | |||
254 | Elf_Dyn_Range Table = DynamicTable.template getAsArrayRef<Elf_Dyn>(); | |||
255 | ||||
256 | size_t Size = 0; | |||
257 | while (Size < Table.size()) | |||
258 | if (Table[Size++].getTag() == DT_NULL) | |||
259 | break; | |||
260 | ||||
261 | return Table.slice(0, Size); | |||
262 | } | |||
263 | ||||
264 | Elf_Sym_Range dynamic_symbols() const { | |||
265 | if (!DynSymRegion) | |||
266 | return Elf_Sym_Range(); | |||
267 | return DynSymRegion->template getAsArrayRef<Elf_Sym>(); | |||
268 | } | |||
269 | ||||
270 | const Elf_Shdr *findSectionByName(StringRef Name) const; | |||
271 | ||||
272 | StringRef getDynamicStringTable() const { return DynamicStringTable; } | |||
273 | ||||
274 | protected: | |||
275 | virtual void printVersionSymbolSection(const Elf_Shdr *Sec) = 0; | |||
276 | virtual void printVersionDefinitionSection(const Elf_Shdr *Sec) = 0; | |||
277 | virtual void printVersionDependencySection(const Elf_Shdr *Sec) = 0; | |||
278 | ||||
279 | void | |||
280 | printDependentLibsHelper(function_ref<void(const Elf_Shdr &)> OnSectionStart, | |||
281 | function_ref<void(StringRef, uint64_t)> OnLibEntry); | |||
282 | ||||
283 | virtual void printRelRelaReloc(const Relocation<ELFT> &R, | |||
284 | const RelSymbol<ELFT> &RelSym) = 0; | |||
285 | virtual void printRelrReloc(const Elf_Relr &R) = 0; | |||
286 | virtual void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
287 | const DynRegionInfo &Reg) {} | |||
288 | void printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
289 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab); | |||
290 | void printDynamicReloc(const Relocation<ELFT> &R); | |||
291 | void printDynamicRelocationsHelper(); | |||
292 | void printRelocationsHelper(const Elf_Shdr &Sec); | |||
293 | void forEachRelocationDo( | |||
294 | const Elf_Shdr &Sec, bool RawRelr, | |||
295 | llvm::function_ref<void(const Relocation<ELFT> &, unsigned, | |||
296 | const Elf_Shdr &, const Elf_Shdr *)> | |||
297 | RelRelaFn, | |||
298 | llvm::function_ref<void(const Elf_Relr &)> RelrFn); | |||
299 | ||||
300 | virtual void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
301 | bool NonVisibilityBitsUsed) const {}; | |||
302 | virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
303 | DataRegion<Elf_Word> ShndxTable, | |||
304 | std::optional<StringRef> StrTable, bool IsDynamic, | |||
305 | bool NonVisibilityBitsUsed) const = 0; | |||
306 | ||||
307 | virtual void printMipsABIFlags() = 0; | |||
308 | virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
309 | virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0; | |||
310 | ||||
311 | virtual void printMemtag( | |||
312 | const ArrayRef<std::pair<std::string, std::string>> DynamicEntries, | |||
313 | const ArrayRef<uint8_t> AndroidNoteDesc, | |||
314 | const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) = 0; | |||
315 | ||||
316 | virtual void printHashHistogram(const Elf_Hash &HashTable) const; | |||
317 | virtual void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable) const; | |||
318 | virtual void printHashHistogramStats(size_t NBucket, size_t MaxChain, | |||
319 | size_t TotalSyms, ArrayRef<size_t> Count, | |||
320 | bool IsGnu) const = 0; | |||
321 | ||||
322 | Expected<ArrayRef<Elf_Versym>> | |||
323 | getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
324 | StringRef *StrTab, const Elf_Shdr **SymTabSec) const; | |||
325 | StringRef getPrintableSectionName(const Elf_Shdr &Sec) const; | |||
326 | ||||
327 | std::vector<GroupSection> getGroups(); | |||
328 | ||||
329 | // Returns the function symbol index for the given address. Matches the | |||
330 | // symbol's section with FunctionSec when specified. | |||
331 | // Returns std::nullopt if no function symbol can be found for the address or | |||
332 | // in case it is not defined in the specified section. | |||
333 | SmallVector<uint32_t> getSymbolIndexesForFunctionAddress( | |||
334 | uint64_t SymValue, std::optional<const Elf_Shdr *> FunctionSec); | |||
335 | bool printFunctionStackSize(uint64_t SymValue, | |||
336 | std::optional<const Elf_Shdr *> FunctionSec, | |||
337 | const Elf_Shdr &StackSizeSec, DataExtractor Data, | |||
338 | uint64_t *Offset); | |||
339 | void printStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec, | |||
340 | unsigned Ndx, const Elf_Shdr *SymTab, | |||
341 | const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec, | |||
342 | const RelocationResolver &Resolver, DataExtractor Data); | |||
343 | virtual void printStackSizeEntry(uint64_t Size, | |||
344 | ArrayRef<std::string> FuncNames) = 0; | |||
345 | ||||
346 | void printRelocatableStackSizes(std::function<void()> PrintHeader); | |||
347 | void printNonRelocatableStackSizes(std::function<void()> PrintHeader); | |||
348 | ||||
349 | const object::ELFObjectFile<ELFT> &ObjF; | |||
350 | const ELFFile<ELFT> &Obj; | |||
351 | StringRef FileName; | |||
352 | ||||
353 | Expected<DynRegionInfo> createDRI(uint64_t Offset, uint64_t Size, | |||
354 | uint64_t EntSize) { | |||
355 | if (Offset + Size < Offset || Offset + Size > Obj.getBufSize()) | |||
356 | return createError("offset (0x" + Twine::utohexstr(Offset) + | |||
357 | ") + size (0x" + Twine::utohexstr(Size) + | |||
358 | ") is greater than the file size (0x" + | |||
359 | Twine::utohexstr(Obj.getBufSize()) + ")"); | |||
360 | return DynRegionInfo(ObjF, *this, Obj.base() + Offset, Size, EntSize); | |||
361 | } | |||
362 | ||||
363 | void printAttributes(unsigned, std::unique_ptr<ELFAttributeParser>, | |||
364 | support::endianness); | |||
365 | void printMipsReginfo(); | |||
366 | void printMipsOptions(); | |||
367 | ||||
368 | std::pair<const Elf_Phdr *, const Elf_Shdr *> findDynamic(); | |||
369 | void loadDynamicTable(); | |||
370 | void parseDynamicTable(); | |||
371 | ||||
372 | Expected<StringRef> getSymbolVersion(const Elf_Sym &Sym, | |||
373 | bool &IsDefault) const; | |||
374 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> getVersionMap() const; | |||
375 | ||||
376 | DynRegionInfo DynRelRegion; | |||
377 | DynRegionInfo DynRelaRegion; | |||
378 | DynRegionInfo DynRelrRegion; | |||
379 | DynRegionInfo DynPLTRelRegion; | |||
380 | std::optional<DynRegionInfo> DynSymRegion; | |||
381 | DynRegionInfo DynSymTabShndxRegion; | |||
382 | DynRegionInfo DynamicTable; | |||
383 | StringRef DynamicStringTable; | |||
384 | const Elf_Hash *HashTable = nullptr; | |||
385 | const Elf_GnuHash *GnuHashTable = nullptr; | |||
386 | const Elf_Shdr *DotSymtabSec = nullptr; | |||
387 | const Elf_Shdr *DotDynsymSec = nullptr; | |||
388 | const Elf_Shdr *DotAddrsigSec = nullptr; | |||
389 | DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables; | |||
390 | std::optional<uint64_t> SONameOffset; | |||
391 | std::optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap; | |||
392 | ||||
393 | const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version | |||
394 | const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r | |||
395 | const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d | |||
396 | ||||
397 | std::string getFullSymbolName(const Elf_Sym &Symbol, unsigned SymIndex, | |||
398 | DataRegion<Elf_Word> ShndxTable, | |||
399 | std::optional<StringRef> StrTable, | |||
400 | bool IsDynamic) const; | |||
401 | Expected<unsigned> | |||
402 | getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
403 | DataRegion<Elf_Word> ShndxTable) const; | |||
404 | Expected<StringRef> getSymbolSectionName(const Elf_Sym &Symbol, | |||
405 | unsigned SectionIndex) const; | |||
406 | std::string getStaticSymbolName(uint32_t Index) const; | |||
407 | StringRef getDynamicString(uint64_t Value) const; | |||
408 | ||||
409 | void printSymbolsHelper(bool IsDynamic) const; | |||
410 | std::string getDynamicEntry(uint64_t Type, uint64_t Value) const; | |||
411 | ||||
412 | Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<ELFT> &R, | |||
413 | const Elf_Shdr *SymTab) const; | |||
414 | ||||
415 | ArrayRef<Elf_Word> getShndxTable(const Elf_Shdr *Symtab) const; | |||
416 | ||||
417 | private: | |||
418 | mutable SmallVector<std::optional<VersionEntry>, 0> VersionMap; | |||
419 | }; | |||
420 | ||||
421 | template <class ELFT> | |||
422 | std::string ELFDumper<ELFT>::describe(const Elf_Shdr &Sec) const { | |||
423 | return ::describe(Obj, Sec); | |||
424 | } | |||
425 | ||||
426 | namespace { | |||
427 | ||||
428 | template <class ELFT> struct SymtabLink { | |||
429 | typename ELFT::SymRange Symbols; | |||
430 | StringRef StringTable; | |||
431 | const typename ELFT::Shdr *SymTab; | |||
432 | }; | |||
433 | ||||
434 | // Returns the linked symbol table, symbols and associated string table for a | |||
435 | // given section. | |||
436 | template <class ELFT> | |||
437 | Expected<SymtabLink<ELFT>> getLinkAsSymtab(const ELFFile<ELFT> &Obj, | |||
438 | const typename ELFT::Shdr &Sec, | |||
439 | unsigned ExpectedType) { | |||
440 | Expected<const typename ELFT::Shdr *> SymtabOrErr = | |||
441 | Obj.getSection(Sec.sh_link); | |||
442 | if (!SymtabOrErr) | |||
443 | return createError("invalid section linked to " + describe(Obj, Sec) + | |||
444 | ": " + toString(SymtabOrErr.takeError())); | |||
445 | ||||
446 | if ((*SymtabOrErr)->sh_type != ExpectedType) | |||
447 | return createError( | |||
448 | "invalid section linked to " + describe(Obj, Sec) + ": expected " + | |||
449 | object::getELFSectionTypeName(Obj.getHeader().e_machine, ExpectedType) + | |||
450 | ", but got " + | |||
451 | object::getELFSectionTypeName(Obj.getHeader().e_machine, | |||
452 | (*SymtabOrErr)->sh_type)); | |||
453 | ||||
454 | Expected<StringRef> StrTabOrErr = Obj.getLinkAsStrtab(**SymtabOrErr); | |||
455 | if (!StrTabOrErr) | |||
456 | return createError( | |||
457 | "can't get a string table for the symbol table linked to " + | |||
458 | describe(Obj, Sec) + ": " + toString(StrTabOrErr.takeError())); | |||
459 | ||||
460 | Expected<typename ELFT::SymRange> SymsOrErr = Obj.symbols(*SymtabOrErr); | |||
461 | if (!SymsOrErr) | |||
462 | return createError("unable to read symbols from the " + describe(Obj, Sec) + | |||
463 | ": " + toString(SymsOrErr.takeError())); | |||
464 | ||||
465 | return SymtabLink<ELFT>{*SymsOrErr, *StrTabOrErr, *SymtabOrErr}; | |||
466 | } | |||
467 | ||||
468 | } // namespace | |||
469 | ||||
470 | template <class ELFT> | |||
471 | Expected<ArrayRef<typename ELFT::Versym>> | |||
472 | ELFDumper<ELFT>::getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab, | |||
473 | StringRef *StrTab, | |||
474 | const Elf_Shdr **SymTabSec) const { | |||
475 | 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", 475, __extension__ __PRETTY_FUNCTION__)); | |||
476 | if (reinterpret_cast<uintptr_t>(Obj.base() + Sec.sh_offset) % | |||
477 | sizeof(uint16_t) != | |||
478 | 0) | |||
479 | return createError("the " + describe(Sec) + " is misaligned"); | |||
480 | ||||
481 | Expected<ArrayRef<Elf_Versym>> VersionsOrErr = | |||
482 | Obj.template getSectionContentsAsArray<Elf_Versym>(Sec); | |||
483 | if (!VersionsOrErr) | |||
484 | return createError("cannot read content of " + describe(Sec) + ": " + | |||
485 | toString(VersionsOrErr.takeError())); | |||
486 | ||||
487 | Expected<SymtabLink<ELFT>> SymTabOrErr = | |||
488 | getLinkAsSymtab(Obj, Sec, SHT_DYNSYM); | |||
489 | if (!SymTabOrErr) { | |||
490 | reportUniqueWarning(SymTabOrErr.takeError()); | |||
491 | return *VersionsOrErr; | |||
492 | } | |||
493 | ||||
494 | if (SymTabOrErr->Symbols.size() != VersionsOrErr->size()) | |||
495 | reportUniqueWarning(describe(Sec) + ": the number of entries (" + | |||
496 | Twine(VersionsOrErr->size()) + | |||
497 | ") does not match the number of symbols (" + | |||
498 | Twine(SymTabOrErr->Symbols.size()) + | |||
499 | ") in the symbol table with index " + | |||
500 | Twine(Sec.sh_link)); | |||
501 | ||||
502 | if (SymTab) { | |||
503 | *SymTab = SymTabOrErr->Symbols; | |||
504 | *StrTab = SymTabOrErr->StringTable; | |||
505 | *SymTabSec = SymTabOrErr->SymTab; | |||
506 | } | |||
507 | return *VersionsOrErr; | |||
508 | } | |||
509 | ||||
510 | template <class ELFT> | |||
511 | void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const { | |||
512 | std::optional<StringRef> StrTable; | |||
513 | size_t Entries = 0; | |||
514 | Elf_Sym_Range Syms(nullptr, nullptr); | |||
515 | const Elf_Shdr *SymtabSec = IsDynamic ? DotDynsymSec : DotSymtabSec; | |||
516 | ||||
517 | if (IsDynamic) { | |||
518 | StrTable = DynamicStringTable; | |||
519 | Syms = dynamic_symbols(); | |||
520 | Entries = Syms.size(); | |||
521 | } else if (DotSymtabSec) { | |||
522 | if (Expected<StringRef> StrTableOrErr = | |||
523 | Obj.getStringTableForSymtab(*DotSymtabSec)) | |||
524 | StrTable = *StrTableOrErr; | |||
525 | else | |||
526 | reportUniqueWarning( | |||
527 | "unable to get the string table for the SHT_SYMTAB section: " + | |||
528 | toString(StrTableOrErr.takeError())); | |||
529 | ||||
530 | if (Expected<Elf_Sym_Range> SymsOrErr = Obj.symbols(DotSymtabSec)) | |||
531 | Syms = *SymsOrErr; | |||
532 | else | |||
533 | reportUniqueWarning( | |||
534 | "unable to read symbols from the SHT_SYMTAB section: " + | |||
535 | toString(SymsOrErr.takeError())); | |||
536 | Entries = DotSymtabSec->getEntityCount(); | |||
537 | } | |||
538 | if (Syms.empty()) | |||
539 | return; | |||
540 | ||||
541 | // The st_other field has 2 logical parts. The first two bits hold the symbol | |||
542 | // visibility (STV_*) and the remainder hold other platform-specific values. | |||
543 | bool NonVisibilityBitsUsed = | |||
544 | llvm::any_of(Syms, [](const Elf_Sym &S) { return S.st_other & ~0x3; }); | |||
545 | ||||
546 | DataRegion<Elf_Word> ShndxTable = | |||
547 | IsDynamic ? DataRegion<Elf_Word>( | |||
548 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, | |||
549 | this->getElfObject().getELFFile().end()) | |||
550 | : DataRegion<Elf_Word>(this->getShndxTable(SymtabSec)); | |||
551 | ||||
552 | printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed); | |||
553 | for (const Elf_Sym &Sym : Syms) | |||
554 | printSymbol(Sym, &Sym - Syms.begin(), ShndxTable, StrTable, IsDynamic, | |||
555 | NonVisibilityBitsUsed); | |||
556 | } | |||
557 | ||||
558 | template <typename ELFT> class GNUELFDumper : public ELFDumper<ELFT> { | |||
559 | formatted_raw_ostream &OS; | |||
560 | ||||
561 | public: | |||
562 | 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; | |||
563 | ||||
564 | GNUELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
565 | : ELFDumper<ELFT>(ObjF, Writer), | |||
566 | OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())) { | |||
567 | 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", 567, __extension__ __PRETTY_FUNCTION__)); | |||
568 | } | |||
569 | ||||
570 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
571 | ArrayRef<std::string> InputFilenames, | |||
572 | const Archive *A) override; | |||
573 | void printFileHeaders() override; | |||
574 | void printGroupSections() override; | |||
575 | void printRelocations() override; | |||
576 | void printSectionHeaders() override; | |||
577 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
578 | void printHashSymbols() override; | |||
579 | void printSectionDetails() override; | |||
580 | void printDependentLibs() override; | |||
581 | void printDynamicTable() override; | |||
582 | void printDynamicRelocations() override; | |||
583 | void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset, | |||
584 | bool NonVisibilityBitsUsed) const override; | |||
585 | void printProgramHeaders(bool PrintProgramHeaders, | |||
586 | cl::boolOrDefault PrintSectionMapping) override; | |||
587 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
588 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
589 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
590 | void printCGProfile() override; | |||
591 | void printBBAddrMaps() override; | |||
592 | void printAddrsig() override; | |||
593 | void printNotes() override; | |||
594 | void printELFLinkerOptions() override; | |||
595 | void printStackSizes() override; | |||
596 | void printMemtag( | |||
597 | const ArrayRef<std::pair<std::string, std::string>> DynamicEntries, | |||
598 | const ArrayRef<uint8_t> AndroidNoteDesc, | |||
599 | const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) override; | |||
600 | void printHashHistogramStats(size_t NBucket, size_t MaxChain, | |||
601 | size_t TotalSyms, ArrayRef<size_t> Count, | |||
602 | bool IsGnu) const override; | |||
603 | ||||
604 | private: | |||
605 | void printHashTableSymbols(const Elf_Hash &HashTable); | |||
606 | void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable); | |||
607 | ||||
608 | struct Field { | |||
609 | std::string Str; | |||
610 | unsigned Column; | |||
611 | ||||
612 | Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {} | |||
613 | Field(unsigned Col) : Column(Col) {} | |||
614 | }; | |||
615 | ||||
616 | template <typename T, typename TEnum> | |||
617 | std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues, | |||
618 | TEnum EnumMask1 = {}, TEnum EnumMask2 = {}, | |||
619 | TEnum EnumMask3 = {}) const { | |||
620 | std::string Str; | |||
621 | for (const EnumEntry<TEnum> &Flag : EnumValues) { | |||
622 | if (Flag.Value == 0) | |||
623 | continue; | |||
624 | ||||
625 | TEnum EnumMask{}; | |||
626 | if (Flag.Value & EnumMask1) | |||
627 | EnumMask = EnumMask1; | |||
628 | else if (Flag.Value & EnumMask2) | |||
629 | EnumMask = EnumMask2; | |||
630 | else if (Flag.Value & EnumMask3) | |||
631 | EnumMask = EnumMask3; | |||
632 | bool IsEnum = (Flag.Value & EnumMask) != 0; | |||
633 | if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || | |||
634 | (IsEnum && (Value & EnumMask) == Flag.Value)) { | |||
635 | if (!Str.empty()) | |||
636 | Str += ", "; | |||
637 | Str += Flag.AltName; | |||
638 | } | |||
639 | } | |||
640 | return Str; | |||
641 | } | |||
642 | ||||
643 | formatted_raw_ostream &printField(struct Field F) const { | |||
644 | if (F.Column != 0) | |||
645 | OS.PadToColumn(F.Column); | |||
646 | OS << F.Str; | |||
647 | OS.flush(); | |||
648 | return OS; | |||
649 | } | |||
650 | void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex, | |||
651 | DataRegion<Elf_Word> ShndxTable, StringRef StrTable, | |||
652 | uint32_t Bucket); | |||
653 | void printRelrReloc(const Elf_Relr &R) override; | |||
654 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
655 | const RelSymbol<ELFT> &RelSym) override; | |||
656 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
657 | DataRegion<Elf_Word> ShndxTable, | |||
658 | std::optional<StringRef> StrTable, bool IsDynamic, | |||
659 | bool NonVisibilityBitsUsed) const override; | |||
660 | void printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
661 | const DynRegionInfo &Reg) override; | |||
662 | ||||
663 | std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex, | |||
664 | DataRegion<Elf_Word> ShndxTable) const; | |||
665 | void printProgramHeaders() override; | |||
666 | void printSectionMapping() override; | |||
667 | void printGNUVersionSectionProlog(const typename ELFT::Shdr &Sec, | |||
668 | const Twine &Label, unsigned EntriesNum); | |||
669 | ||||
670 | void printStackSizeEntry(uint64_t Size, | |||
671 | ArrayRef<std::string> FuncNames) override; | |||
672 | ||||
673 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
674 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
675 | void printMipsABIFlags() override; | |||
676 | }; | |||
677 | ||||
678 | template <typename ELFT> class LLVMELFDumper : public ELFDumper<ELFT> { | |||
679 | public: | |||
680 | 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; | |||
681 | ||||
682 | LLVMELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
683 | : ELFDumper<ELFT>(ObjF, Writer), W(Writer) {} | |||
684 | ||||
685 | void printFileHeaders() override; | |||
686 | void printGroupSections() override; | |||
687 | void printRelocations() override; | |||
688 | void printSectionHeaders() override; | |||
689 | void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; | |||
690 | void printDependentLibs() override; | |||
691 | void printDynamicTable() override; | |||
692 | void printDynamicRelocations() override; | |||
693 | void printProgramHeaders(bool PrintProgramHeaders, | |||
694 | cl::boolOrDefault PrintSectionMapping) override; | |||
695 | void printVersionSymbolSection(const Elf_Shdr *Sec) override; | |||
696 | void printVersionDefinitionSection(const Elf_Shdr *Sec) override; | |||
697 | void printVersionDependencySection(const Elf_Shdr *Sec) override; | |||
698 | void printCGProfile() override; | |||
699 | void printBBAddrMaps() override; | |||
700 | void printAddrsig() override; | |||
701 | void printNotes() override; | |||
702 | void printELFLinkerOptions() override; | |||
703 | void printStackSizes() override; | |||
704 | void printMemtag( | |||
705 | const ArrayRef<std::pair<std::string, std::string>> DynamicEntries, | |||
706 | const ArrayRef<uint8_t> AndroidNoteDesc, | |||
707 | const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) override; | |||
708 | void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex, | |||
709 | DataRegion<Elf_Word> ShndxTable) const; | |||
710 | void printHashHistogramStats(size_t NBucket, size_t MaxChain, | |||
711 | size_t TotalSyms, ArrayRef<size_t> Count, | |||
712 | bool IsGnu) const override; | |||
713 | ||||
714 | private: | |||
715 | void printRelrReloc(const Elf_Relr &R) override; | |||
716 | void printRelRelaReloc(const Relocation<ELFT> &R, | |||
717 | const RelSymbol<ELFT> &RelSym) override; | |||
718 | ||||
719 | void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
720 | DataRegion<Elf_Word> ShndxTable, | |||
721 | std::optional<StringRef> StrTable, bool IsDynamic, | |||
722 | bool /*NonVisibilityBitsUsed*/) const override; | |||
723 | void printProgramHeaders() override; | |||
724 | void printSectionMapping() override {} | |||
725 | void printStackSizeEntry(uint64_t Size, | |||
726 | ArrayRef<std::string> FuncNames) override; | |||
727 | ||||
728 | void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; | |||
729 | void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; | |||
730 | void printMipsABIFlags() override; | |||
731 | virtual void printZeroSymbolOtherField(const Elf_Sym &Symbol) const; | |||
732 | ||||
733 | protected: | |||
734 | virtual std::string getGroupSectionHeaderName() const; | |||
735 | void printSymbolOtherField(const Elf_Sym &Symbol) const; | |||
736 | virtual void printExpandedRelRelaReloc(const Relocation<ELFT> &R, | |||
737 | StringRef SymbolName, | |||
738 | StringRef RelocName); | |||
739 | virtual void printDefaultRelRelaReloc(const Relocation<ELFT> &R, | |||
740 | StringRef SymbolName, | |||
741 | StringRef RelocName); | |||
742 | virtual void printRelocationSectionInfo(const Elf_Shdr &Sec, StringRef Name, | |||
743 | const unsigned SecNdx); | |||
744 | virtual void printSectionGroupMembers(StringRef Name, uint64_t Idx) const; | |||
745 | virtual void printEmptyGroupMessage() const; | |||
746 | ||||
747 | ScopedPrinter &W; | |||
748 | }; | |||
749 | ||||
750 | // JSONELFDumper shares most of the same implementation as LLVMELFDumper except | |||
751 | // it uses a JSONScopedPrinter. | |||
752 | template <typename ELFT> class JSONELFDumper : public LLVMELFDumper<ELFT> { | |||
753 | public: | |||
754 | 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; | |||
755 | ||||
756 | JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer) | |||
757 | : LLVMELFDumper<ELFT>(ObjF, Writer) {} | |||
758 | ||||
759 | std::string getGroupSectionHeaderName() const override; | |||
760 | ||||
761 | void printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
762 | ArrayRef<std::string> InputFilenames, | |||
763 | const Archive *A) override; | |||
764 | virtual void printZeroSymbolOtherField(const Elf_Sym &Symbol) const override; | |||
765 | ||||
766 | void printDefaultRelRelaReloc(const Relocation<ELFT> &R, | |||
767 | StringRef SymbolName, | |||
768 | StringRef RelocName) override; | |||
769 | ||||
770 | void printRelocationSectionInfo(const Elf_Shdr &Sec, StringRef Name, | |||
771 | const unsigned SecNdx) override; | |||
772 | ||||
773 | void printSectionGroupMembers(StringRef Name, uint64_t Idx) const override; | |||
774 | ||||
775 | void printEmptyGroupMessage() const override; | |||
776 | ||||
777 | private: | |||
778 | std::unique_ptr<DictScope> FileScope; | |||
779 | }; | |||
780 | ||||
781 | } // end anonymous namespace | |||
782 | ||||
783 | namespace llvm { | |||
784 | ||||
785 | template <class ELFT> | |||
786 | static std::unique_ptr<ObjDumper> | |||
787 | createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) { | |||
788 | if (opts::Output == opts::GNU) | |||
789 | return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer); | |||
790 | else if (opts::Output == opts::JSON) | |||
791 | return std::make_unique<JSONELFDumper<ELFT>>(Obj, Writer); | |||
792 | return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer); | |||
793 | } | |||
794 | ||||
795 | std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj, | |||
796 | ScopedPrinter &Writer) { | |||
797 | // Little-endian 32-bit | |||
798 | if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj)) | |||
799 | return createELFDumper(*ELFObj, Writer); | |||
800 | ||||
801 | // Big-endian 32-bit | |||
802 | if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj)) | |||
803 | return createELFDumper(*ELFObj, Writer); | |||
804 | ||||
805 | // Little-endian 64-bit | |||
806 | if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj)) | |||
807 | return createELFDumper(*ELFObj, Writer); | |||
808 | ||||
809 | // Big-endian 64-bit | |||
810 | return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer); | |||
811 | } | |||
812 | ||||
813 | } // end namespace llvm | |||
814 | ||||
815 | template <class ELFT> | |||
816 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> | |||
817 | ELFDumper<ELFT>::getVersionMap() const { | |||
818 | // If the VersionMap has already been loaded or if there is no dynamic symtab | |||
819 | // or version table, there is nothing to do. | |||
820 | if (!VersionMap.empty() || !DynSymRegion || !SymbolVersionSection) | |||
821 | return &VersionMap; | |||
822 | ||||
823 | Expected<SmallVector<std::optional<VersionEntry>, 0>> MapOrErr = | |||
824 | Obj.loadVersionMap(SymbolVersionNeedSection, SymbolVersionDefSection); | |||
825 | if (MapOrErr) | |||
826 | VersionMap = *MapOrErr; | |||
827 | else | |||
828 | return MapOrErr.takeError(); | |||
829 | ||||
830 | return &VersionMap; | |||
831 | } | |||
832 | ||||
833 | template <typename ELFT> | |||
834 | Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym &Sym, | |||
835 | bool &IsDefault) const { | |||
836 | // This is a dynamic symbol. Look in the GNU symbol version table. | |||
837 | if (!SymbolVersionSection) { | |||
838 | // No version table. | |||
839 | IsDefault = false; | |||
840 | return ""; | |||
841 | } | |||
842 | ||||
843 | 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", 843, __extension__ __PRETTY_FUNCTION__)); | |||
844 | // Determine the position in the symbol table of this entry. | |||
845 | size_t EntryIndex = (reinterpret_cast<uintptr_t>(&Sym) - | |||
846 | reinterpret_cast<uintptr_t>(DynSymRegion->Addr)) / | |||
847 | sizeof(Elf_Sym); | |||
848 | ||||
849 | // Get the corresponding version index entry. | |||
850 | Expected<const Elf_Versym *> EntryOrErr = | |||
851 | Obj.template getEntry<Elf_Versym>(*SymbolVersionSection, EntryIndex); | |||
852 | if (!EntryOrErr) | |||
853 | return EntryOrErr.takeError(); | |||
854 | ||||
855 | unsigned Version = (*EntryOrErr)->vs_index; | |||
856 | if (Version == VER_NDX_LOCAL || Version == VER_NDX_GLOBAL) { | |||
857 | IsDefault = false; | |||
858 | return ""; | |||
859 | } | |||
860 | ||||
861 | Expected<SmallVector<std::optional<VersionEntry>, 0> *> MapOrErr = | |||
862 | getVersionMap(); | |||
863 | if (!MapOrErr) | |||
864 | return MapOrErr.takeError(); | |||
865 | ||||
866 | return Obj.getSymbolVersionByIndex(Version, IsDefault, **MapOrErr, | |||
867 | Sym.st_shndx == ELF::SHN_UNDEF); | |||
868 | } | |||
869 | ||||
870 | template <typename ELFT> | |||
871 | Expected<RelSymbol<ELFT>> | |||
872 | ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R, | |||
873 | const Elf_Shdr *SymTab) const { | |||
874 | if (R.Symbol == 0) | |||
875 | return RelSymbol<ELFT>(nullptr, ""); | |||
876 | ||||
877 | Expected<const Elf_Sym *> SymOrErr = | |||
878 | Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol); | |||
879 | if (!SymOrErr) | |||
880 | return createError("unable to read an entry with index " + Twine(R.Symbol) + | |||
881 | " from " + describe(*SymTab) + ": " + | |||
882 | toString(SymOrErr.takeError())); | |||
883 | const Elf_Sym *Sym = *SymOrErr; | |||
884 | if (!Sym) | |||
885 | return RelSymbol<ELFT>(nullptr, ""); | |||
886 | ||||
887 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*SymTab); | |||
888 | if (!StrTableOrErr) | |||
889 | return StrTableOrErr.takeError(); | |||
890 | ||||
891 | const Elf_Sym *FirstSym = | |||
892 | cantFail(Obj.template getEntry<Elf_Sym>(*SymTab, 0)); | |||
893 | std::string SymbolName = | |||
894 | getFullSymbolName(*Sym, Sym - FirstSym, getShndxTable(SymTab), | |||
895 | *StrTableOrErr, SymTab->sh_type == SHT_DYNSYM); | |||
896 | return RelSymbol<ELFT>(Sym, SymbolName); | |||
897 | } | |||
898 | ||||
899 | template <typename ELFT> | |||
900 | ArrayRef<typename ELFT::Word> | |||
901 | ELFDumper<ELFT>::getShndxTable(const Elf_Shdr *Symtab) const { | |||
902 | if (Symtab) { | |||
903 | auto It = ShndxTables.find(Symtab); | |||
904 | if (It != ShndxTables.end()) | |||
905 | return It->second; | |||
906 | } | |||
907 | return {}; | |||
908 | } | |||
909 | ||||
910 | static std::string maybeDemangle(StringRef Name) { | |||
911 | return opts::Demangle ? demangle(std::string(Name)) : Name.str(); | |||
912 | } | |||
913 | ||||
914 | template <typename ELFT> | |||
915 | std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const { | |||
916 | auto Warn = [&](Error E) -> std::string { | |||
917 | reportUniqueWarning("unable to read the name of symbol with index " + | |||
918 | Twine(Index) + ": " + toString(std::move(E))); | |||
919 | return "<?>"; | |||
920 | }; | |||
921 | ||||
922 | Expected<const typename ELFT::Sym *> SymOrErr = | |||
923 | Obj.getSymbol(DotSymtabSec, Index); | |||
924 | if (!SymOrErr) | |||
925 | return Warn(SymOrErr.takeError()); | |||
926 | ||||
927 | Expected<StringRef> StrTabOrErr = Obj.getStringTableForSymtab(*DotSymtabSec); | |||
928 | if (!StrTabOrErr) | |||
929 | return Warn(StrTabOrErr.takeError()); | |||
930 | ||||
931 | Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr); | |||
932 | if (!NameOrErr) | |||
933 | return Warn(NameOrErr.takeError()); | |||
934 | return maybeDemangle(*NameOrErr); | |||
935 | } | |||
936 | ||||
937 | template <typename ELFT> | |||
938 | std::string ELFDumper<ELFT>::getFullSymbolName( | |||
939 | const Elf_Sym &Symbol, unsigned SymIndex, DataRegion<Elf_Word> ShndxTable, | |||
940 | std::optional<StringRef> StrTable, bool IsDynamic) const { | |||
941 | if (!StrTable) | |||
942 | return "<?>"; | |||
943 | ||||
944 | std::string SymbolName; | |||
945 | if (Expected<StringRef> NameOrErr = Symbol.getName(*StrTable)) { | |||
946 | SymbolName = maybeDemangle(*NameOrErr); | |||
947 | } else { | |||
948 | reportUniqueWarning(NameOrErr.takeError()); | |||
949 | return "<?>"; | |||
950 | } | |||
951 | ||||
952 | if (SymbolName.empty() && Symbol.getType() == ELF::STT_SECTION) { | |||
953 | Expected<unsigned> SectionIndex = | |||
954 | getSymbolSectionIndex(Symbol, SymIndex, ShndxTable); | |||
955 | if (!SectionIndex) { | |||
956 | reportUniqueWarning(SectionIndex.takeError()); | |||
957 | return "<?>"; | |||
958 | } | |||
959 | Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex); | |||
960 | if (!NameOrErr) { | |||
961 | reportUniqueWarning(NameOrErr.takeError()); | |||
962 | return ("<section " + Twine(*SectionIndex) + ">").str(); | |||
963 | } | |||
964 | return std::string(*NameOrErr); | |||
965 | } | |||
966 | ||||
967 | if (!IsDynamic) | |||
968 | return SymbolName; | |||
969 | ||||
970 | bool IsDefault; | |||
971 | Expected<StringRef> VersionOrErr = getSymbolVersion(Symbol, IsDefault); | |||
972 | if (!VersionOrErr) { | |||
973 | reportUniqueWarning(VersionOrErr.takeError()); | |||
974 | return SymbolName + "@<corrupt>"; | |||
975 | } | |||
976 | ||||
977 | if (!VersionOrErr->empty()) { | |||
978 | SymbolName += (IsDefault ? "@@" : "@"); | |||
979 | SymbolName += *VersionOrErr; | |||
980 | } | |||
981 | return SymbolName; | |||
982 | } | |||
983 | ||||
984 | template <typename ELFT> | |||
985 | Expected<unsigned> | |||
986 | ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex, | |||
987 | DataRegion<Elf_Word> ShndxTable) const { | |||
988 | unsigned Ndx = Symbol.st_shndx; | |||
989 | if (Ndx == SHN_XINDEX) | |||
990 | return object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, | |||
991 | ShndxTable); | |||
992 | if (Ndx != SHN_UNDEF && Ndx < SHN_LORESERVE) | |||
993 | return Ndx; | |||
994 | ||||
995 | auto CreateErr = [&](const Twine &Name, | |||
996 | std::optional<unsigned> Offset = std::nullopt) { | |||
997 | std::string Desc; | |||
998 | if (Offset) | |||
999 | Desc = (Name + "+0x" + Twine::utohexstr(*Offset)).str(); | |||
1000 | else | |||
1001 | Desc = Name.str(); | |||
1002 | return createError( | |||
1003 | "unable to get section index for symbol with st_shndx = 0x" + | |||
1004 | Twine::utohexstr(Ndx) + " (" + Desc + ")"); | |||
1005 | }; | |||
1006 | ||||
1007 | if (Ndx >= ELF::SHN_LOPROC && Ndx <= ELF::SHN_HIPROC) | |||
1008 | return CreateErr("SHN_LOPROC", Ndx - ELF::SHN_LOPROC); | |||
1009 | if (Ndx >= ELF::SHN_LOOS && Ndx <= ELF::SHN_HIOS) | |||
1010 | return CreateErr("SHN_LOOS", Ndx - ELF::SHN_LOOS); | |||
1011 | if (Ndx == ELF::SHN_UNDEF) | |||
1012 | return CreateErr("SHN_UNDEF"); | |||
1013 | if (Ndx == ELF::SHN_ABS) | |||
1014 | return CreateErr("SHN_ABS"); | |||
1015 | if (Ndx == ELF::SHN_COMMON) | |||
1016 | return CreateErr("SHN_COMMON"); | |||
1017 | return CreateErr("SHN_LORESERVE", Ndx - SHN_LORESERVE); | |||
1018 | } | |||
1019 | ||||
1020 | template <typename ELFT> | |||
1021 | Expected<StringRef> | |||
1022 | ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym &Symbol, | |||
1023 | unsigned SectionIndex) const { | |||
1024 | Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(SectionIndex); | |||
1025 | if (!SecOrErr) | |||
1026 | return SecOrErr.takeError(); | |||
1027 | return Obj.getSectionName(**SecOrErr); | |||
1028 | } | |||
1029 | ||||
1030 | template <class ELFO> | |||
1031 | static const typename ELFO::Elf_Shdr * | |||
1032 | findNotEmptySectionByAddress(const ELFO &Obj, StringRef FileName, | |||
1033 | uint64_t Addr) { | |||
1034 | for (const typename ELFO::Elf_Shdr &Shdr : cantFail(Obj.sections())) | |||
1035 | if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) | |||
1036 | return &Shdr; | |||
1037 | return nullptr; | |||
1038 | } | |||
1039 | ||||
1040 | const EnumEntry<unsigned> ElfClass[] = { | |||
1041 | {"None", "none", ELF::ELFCLASSNONE}, | |||
1042 | {"32-bit", "ELF32", ELF::ELFCLASS32}, | |||
1043 | {"64-bit", "ELF64", ELF::ELFCLASS64}, | |||
1044 | }; | |||
1045 | ||||
1046 | const EnumEntry<unsigned> ElfDataEncoding[] = { | |||
1047 | {"None", "none", ELF::ELFDATANONE}, | |||
1048 | {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, | |||
1049 | {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, | |||
1050 | }; | |||
1051 | ||||
1052 | const EnumEntry<unsigned> ElfObjectFileType[] = { | |||
1053 | {"None", "NONE (none)", ELF::ET_NONE}, | |||
1054 | {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, | |||
1055 | {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, | |||
1056 | {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, | |||
1057 | {"Core", "CORE (Core file)", ELF::ET_CORE}, | |||
1058 | }; | |||
1059 | ||||
1060 | const EnumEntry<unsigned> ElfOSABI[] = { | |||
1061 | {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, | |||
1062 | {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, | |||
1063 | {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, | |||
1064 | {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, | |||
1065 | {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, | |||
1066 | {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, | |||
1067 | {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, | |||
1068 | {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, | |||
1069 | {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, | |||
1070 | {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, | |||
1071 | {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, | |||
1072 | {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, | |||
1073 | {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, | |||
1074 | {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, | |||
1075 | {"AROS", "AROS", ELF::ELFOSABI_AROS}, | |||
1076 | {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, | |||
1077 | {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, | |||
1078 | {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} | |||
1079 | }; | |||
1080 | ||||
1081 | const EnumEntry<unsigned> AMDGPUElfOSABI[] = { | |||
1082 | {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA}, | |||
1083 | {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}, | |||
1084 | {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D} | |||
1085 | }; | |||
1086 | ||||
1087 | const EnumEntry<unsigned> ARMElfOSABI[] = { | |||
1088 | {"ARM", "ARM", ELF::ELFOSABI_ARM} | |||
1089 | }; | |||
1090 | ||||
1091 | const EnumEntry<unsigned> C6000ElfOSABI[] = { | |||
1092 | {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, | |||
1093 | {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX} | |||
1094 | }; | |||
1095 | ||||
1096 | const EnumEntry<unsigned> ElfMachineType[] = { | |||
1097 | ENUM_ENT(EM_NONE, "None"){ "EM_NONE", "None", ELF::EM_NONE }, | |||
1098 | ENUM_ENT(EM_M32, "WE32100"){ "EM_M32", "WE32100", ELF::EM_M32 }, | |||
1099 | ENUM_ENT(EM_SPARC, "Sparc"){ "EM_SPARC", "Sparc", ELF::EM_SPARC }, | |||
1100 | ENUM_ENT(EM_386, "Intel 80386"){ "EM_386", "Intel 80386", ELF::EM_386 }, | |||
1101 | ENUM_ENT(EM_68K, "MC68000"){ "EM_68K", "MC68000", ELF::EM_68K }, | |||
1102 | ENUM_ENT(EM_88K, "MC88000"){ "EM_88K", "MC88000", ELF::EM_88K }, | |||
1103 | ENUM_ENT(EM_IAMCU, "EM_IAMCU"){ "EM_IAMCU", "EM_IAMCU", ELF::EM_IAMCU }, | |||
1104 | ENUM_ENT(EM_860, "Intel 80860"){ "EM_860", "Intel 80860", ELF::EM_860 }, | |||
1105 | ENUM_ENT(EM_MIPS, "MIPS R3000"){ "EM_MIPS", "MIPS R3000", ELF::EM_MIPS }, | |||
1106 | ENUM_ENT(EM_S370, "IBM System/370"){ "EM_S370", "IBM System/370", ELF::EM_S370 }, | |||
1107 | ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"){ "EM_MIPS_RS3_LE", "MIPS R3000 little-endian", ELF::EM_MIPS_RS3_LE }, | |||
1108 | ENUM_ENT(EM_PARISC, "HPPA"){ "EM_PARISC", "HPPA", ELF::EM_PARISC }, | |||
1109 | ENUM_ENT(EM_VPP500, "Fujitsu VPP500"){ "EM_VPP500", "Fujitsu VPP500", ELF::EM_VPP500 }, | |||
1110 | ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"){ "EM_SPARC32PLUS", "Sparc v8+", ELF::EM_SPARC32PLUS }, | |||
1111 | ENUM_ENT(EM_960, "Intel 80960"){ "EM_960", "Intel 80960", ELF::EM_960 }, | |||
1112 | ENUM_ENT(EM_PPC, "PowerPC"){ "EM_PPC", "PowerPC", ELF::EM_PPC }, | |||
1113 | ENUM_ENT(EM_PPC64, "PowerPC64"){ "EM_PPC64", "PowerPC64", ELF::EM_PPC64 }, | |||
1114 | ENUM_ENT(EM_S390, "IBM S/390"){ "EM_S390", "IBM S/390", ELF::EM_S390 }, | |||
1115 | ENUM_ENT(EM_SPU, "SPU"){ "EM_SPU", "SPU", ELF::EM_SPU }, | |||
1116 | ENUM_ENT(EM_V800, "NEC V800 series"){ "EM_V800", "NEC V800 series", ELF::EM_V800 }, | |||
1117 | ENUM_ENT(EM_FR20, "Fujistsu FR20"){ "EM_FR20", "Fujistsu FR20", ELF::EM_FR20 }, | |||
1118 | ENUM_ENT(EM_RH32, "TRW RH-32"){ "EM_RH32", "TRW RH-32", ELF::EM_RH32 }, | |||
1119 | ENUM_ENT(EM_RCE, "Motorola RCE"){ "EM_RCE", "Motorola RCE", ELF::EM_RCE }, | |||
1120 | ENUM_ENT(EM_ARM, "ARM"){ "EM_ARM", "ARM", ELF::EM_ARM }, | |||
1121 | ENUM_ENT(EM_ALPHA, "EM_ALPHA"){ "EM_ALPHA", "EM_ALPHA", ELF::EM_ALPHA }, | |||
1122 | ENUM_ENT(EM_SH, "Hitachi SH"){ "EM_SH", "Hitachi SH", ELF::EM_SH }, | |||
1123 | ENUM_ENT(EM_SPARCV9, "Sparc v9"){ "EM_SPARCV9", "Sparc v9", ELF::EM_SPARCV9 }, | |||
1124 | ENUM_ENT(EM_TRICORE, "Siemens Tricore"){ "EM_TRICORE", "Siemens Tricore", ELF::EM_TRICORE }, | |||
1125 | ENUM_ENT(EM_ARC, "ARC"){ "EM_ARC", "ARC", ELF::EM_ARC }, | |||
1126 | ENUM_ENT(EM_H8_300, "Hitachi H8/300"){ "EM_H8_300", "Hitachi H8/300", ELF::EM_H8_300 }, | |||
1127 | ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"){ "EM_H8_300H", "Hitachi H8/300H", ELF::EM_H8_300H }, | |||
1128 | ENUM_ENT(EM_H8S, "Hitachi H8S"){ "EM_H8S", "Hitachi H8S", ELF::EM_H8S }, | |||
1129 | ENUM_ENT(EM_H8_500, "Hitachi H8/500"){ "EM_H8_500", "Hitachi H8/500", ELF::EM_H8_500 }, | |||
1130 | ENUM_ENT(EM_IA_64, "Intel IA-64"){ "EM_IA_64", "Intel IA-64", ELF::EM_IA_64 }, | |||
1131 | ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"){ "EM_MIPS_X", "Stanford MIPS-X", ELF::EM_MIPS_X }, | |||
1132 | ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"){ "EM_COLDFIRE", "Motorola Coldfire", ELF::EM_COLDFIRE }, | |||
1133 | ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"){ "EM_68HC12", "Motorola MC68HC12 Microcontroller", ELF::EM_68HC12 }, | |||
1134 | ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"){ "EM_MMA", "Fujitsu Multimedia Accelerator", ELF::EM_MMA }, | |||
1135 | ENUM_ENT(EM_PCP, "Siemens PCP"){ "EM_PCP", "Siemens PCP", ELF::EM_PCP }, | |||
1136 | ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"){ "EM_NCPU", "Sony nCPU embedded RISC processor", ELF::EM_NCPU }, | |||
1137 | ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"){ "EM_NDR1", "Denso NDR1 microprocesspr", ELF::EM_NDR1 }, | |||
1138 | ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"){ "EM_STARCORE", "Motorola Star*Core processor", ELF::EM_STARCORE }, | |||
1139 | ENUM_ENT(EM_ME16, "Toyota ME16 processor"){ "EM_ME16", "Toyota ME16 processor", ELF::EM_ME16 }, | |||
1140 | ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"){ "EM_ST100", "STMicroelectronics ST100 processor", ELF::EM_ST100 }, | |||
1141 | ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"){ "EM_TINYJ", "Advanced Logic Corp. TinyJ embedded processor" , ELF::EM_TINYJ }, | |||
1142 | ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"){ "EM_X86_64", "Advanced Micro Devices X86-64", ELF::EM_X86_64 }, | |||
1143 | ENUM_ENT(EM_PDSP, "Sony DSP processor"){ "EM_PDSP", "Sony DSP processor", ELF::EM_PDSP }, | |||
1144 | ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"){ "EM_PDP10", "Digital Equipment Corp. PDP-10", ELF::EM_PDP10 }, | |||
1145 | ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"){ "EM_PDP11", "Digital Equipment Corp. PDP-11", ELF::EM_PDP11 }, | |||
1146 | ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"){ "EM_FX66", "Siemens FX66 microcontroller", ELF::EM_FX66 }, | |||
1147 | ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"){ "EM_ST9PLUS", "STMicroelectronics ST9+ 8/16 bit microcontroller" , ELF::EM_ST9PLUS }, | |||
1148 | ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"){ "EM_ST7", "STMicroelectronics ST7 8-bit microcontroller", ELF ::EM_ST7 }, | |||
1149 | ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"){ "EM_68HC16", "Motorola MC68HC16 Microcontroller", ELF::EM_68HC16 }, | |||
1150 | ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"){ "EM_68HC11", "Motorola MC68HC11 Microcontroller", ELF::EM_68HC11 }, | |||
1151 | ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"){ "EM_68HC08", "Motorola MC68HC08 Microcontroller", ELF::EM_68HC08 }, | |||
1152 | ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"){ "EM_68HC05", "Motorola MC68HC05 Microcontroller", ELF::EM_68HC05 }, | |||
1153 | ENUM_ENT(EM_SVX, "Silicon Graphics SVx"){ "EM_SVX", "Silicon Graphics SVx", ELF::EM_SVX }, | |||
1154 | ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"){ "EM_ST19", "STMicroelectronics ST19 8-bit microcontroller", ELF::EM_ST19 }, | |||
1155 | ENUM_ENT(EM_VAX, "Digital VAX"){ "EM_VAX", "Digital VAX", ELF::EM_VAX }, | |||
1156 | ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"){ "EM_CRIS", "Axis Communications 32-bit embedded processor", ELF::EM_CRIS }, | |||
1157 | ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"){ "EM_JAVELIN", "Infineon Technologies 32-bit embedded cpu", ELF ::EM_JAVELIN }, | |||
1158 | ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"){ "EM_FIREPATH", "Element 14 64-bit DSP processor", ELF::EM_FIREPATH }, | |||
1159 | ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"){ "EM_ZSP", "LSI Logic's 16-bit DSP processor", ELF::EM_ZSP }, | |||
1160 | ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"){ "EM_MMIX", "Donald Knuth's educational 64-bit processor", ELF ::EM_MMIX }, | |||
1161 | ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"){ "EM_HUANY", "Harvard Universitys's machine-independent object format" , ELF::EM_HUANY }, | |||
1162 | ENUM_ENT(EM_PRISM, "Vitesse Prism"){ "EM_PRISM", "Vitesse Prism", ELF::EM_PRISM }, | |||
1163 | ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"){ "EM_AVR", "Atmel AVR 8-bit microcontroller", ELF::EM_AVR }, | |||
1164 | ENUM_ENT(EM_FR30, "Fujitsu FR30"){ "EM_FR30", "Fujitsu FR30", ELF::EM_FR30 }, | |||
1165 | ENUM_ENT(EM_D10V, "Mitsubishi D10V"){ "EM_D10V", "Mitsubishi D10V", ELF::EM_D10V }, | |||
1166 | ENUM_ENT(EM_D30V, "Mitsubishi D30V"){ "EM_D30V", "Mitsubishi D30V", ELF::EM_D30V }, | |||
1167 | ENUM_ENT(EM_V850, "NEC v850"){ "EM_V850", "NEC v850", ELF::EM_V850 }, | |||
1168 | ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"){ "EM_M32R", "Renesas M32R (formerly Mitsubishi M32r)", ELF:: EM_M32R }, | |||
1169 | ENUM_ENT(EM_MN10300, "Matsushita MN10300"){ "EM_MN10300", "Matsushita MN10300", ELF::EM_MN10300 }, | |||
1170 | ENUM_ENT(EM_MN10200, "Matsushita MN10200"){ "EM_MN10200", "Matsushita MN10200", ELF::EM_MN10200 }, | |||
1171 | ENUM_ENT(EM_PJ, "picoJava"){ "EM_PJ", "picoJava", ELF::EM_PJ }, | |||
1172 | ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"){ "EM_OPENRISC", "OpenRISC 32-bit embedded processor", ELF::EM_OPENRISC }, | |||
1173 | ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"){ "EM_ARC_COMPACT", "EM_ARC_COMPACT", ELF::EM_ARC_COMPACT }, | |||
1174 | ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"){ "EM_XTENSA", "Tensilica Xtensa Processor", ELF::EM_XTENSA }, | |||
1175 | ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"){ "EM_VIDEOCORE", "Alphamosaic VideoCore processor", ELF::EM_VIDEOCORE }, | |||
1176 | ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"){ "EM_TMM_GPP", "Thompson Multimedia General Purpose Processor" , ELF::EM_TMM_GPP }, | |||
1177 | ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"){ "EM_NS32K", "National Semiconductor 32000 series", ELF::EM_NS32K }, | |||
1178 | ENUM_ENT(EM_TPC, "Tenor Network TPC processor"){ "EM_TPC", "Tenor Network TPC processor", ELF::EM_TPC }, | |||
1179 | ENUM_ENT(EM_SNP1K, "EM_SNP1K"){ "EM_SNP1K", "EM_SNP1K", ELF::EM_SNP1K }, | |||
1180 | ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"){ "EM_ST200", "STMicroelectronics ST200 microcontroller", ELF ::EM_ST200 }, | |||
1181 | ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"){ "EM_IP2K", "Ubicom IP2xxx 8-bit microcontrollers", ELF::EM_IP2K }, | |||
1182 | ENUM_ENT(EM_MAX, "MAX Processor"){ "EM_MAX", "MAX Processor", ELF::EM_MAX }, | |||
1183 | ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"){ "EM_CR", "National Semiconductor CompactRISC", ELF::EM_CR }, | |||
1184 | ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"){ "EM_F2MC16", "Fujitsu F2MC16", ELF::EM_F2MC16 }, | |||
1185 | ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"){ "EM_MSP430", "Texas Instruments msp430 microcontroller", ELF ::EM_MSP430 }, | |||
1186 | ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"){ "EM_BLACKFIN", "Analog Devices Blackfin", ELF::EM_BLACKFIN }, | |||
1187 | ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"){ "EM_SE_C33", "S1C33 Family of Seiko Epson processors", ELF:: EM_SE_C33 }, | |||
1188 | ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"){ "EM_SEP", "Sharp embedded microprocessor", ELF::EM_SEP }, | |||
1189 | ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"){ "EM_ARCA", "Arca RISC microprocessor", ELF::EM_ARCA }, | |||
1190 | ENUM_ENT(EM_UNICORE, "Unicore"){ "EM_UNICORE", "Unicore", ELF::EM_UNICORE }, | |||
1191 | 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 }, | |||
1192 | ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"){ "EM_DXP", "Icera Semiconductor Inc. Deep Execution Processor" , ELF::EM_DXP }, | |||
1193 | ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"){ "EM_ALTERA_NIOS2", "Altera Nios", ELF::EM_ALTERA_NIOS2 }, | |||
1194 | ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"){ "EM_CRX", "National Semiconductor CRX microprocessor", ELF:: EM_CRX }, | |||
1195 | ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"){ "EM_XGATE", "Motorola XGATE embedded processor", ELF::EM_XGATE }, | |||
1196 | ENUM_ENT(EM_C166, "Infineon Technologies xc16x"){ "EM_C166", "Infineon Technologies xc16x", ELF::EM_C166 }, | |||
1197 | ENUM_ENT(EM_M16C, "Renesas M16C"){ "EM_M16C", "Renesas M16C", ELF::EM_M16C }, | |||
1198 | ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"){ "EM_DSPIC30F", "Microchip Technology dsPIC30F Digital Signal Controller" , ELF::EM_DSPIC30F }, | |||
1199 | ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"){ "EM_CE", "Freescale Communication Engine RISC core", ELF::EM_CE }, | |||
1200 | ENUM_ENT(EM_M32C, "Renesas M32C"){ "EM_M32C", "Renesas M32C", ELF::EM_M32C }, | |||
1201 | ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"){ "EM_TSK3000", "Altium TSK3000 core", ELF::EM_TSK3000 }, | |||
1202 | ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"){ "EM_RS08", "Freescale RS08 embedded processor", ELF::EM_RS08 }, | |||
1203 | ENUM_ENT(EM_SHARC, "EM_SHARC"){ "EM_SHARC", "EM_SHARC", ELF::EM_SHARC }, | |||
1204 | ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"){ "EM_ECOG2", "Cyan Technology eCOG2 microprocessor", ELF::EM_ECOG2 }, | |||
1205 | ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"){ "EM_SCORE7", "SUNPLUS S+Core", ELF::EM_SCORE7 }, | |||
1206 | 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 }, | |||
1207 | ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"){ "EM_VIDEOCORE3", "Broadcom VideoCore III processor", ELF::EM_VIDEOCORE3 }, | |||
1208 | ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"){ "EM_LATTICEMICO32", "Lattice Mico32", ELF::EM_LATTICEMICO32 }, | |||
1209 | ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"){ "EM_SE_C17", "Seiko Epson C17 family", ELF::EM_SE_C17 }, | |||
1210 | ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"){ "EM_TI_C6000", "Texas Instruments TMS320C6000 DSP family", ELF ::EM_TI_C6000 }, | |||
1211 | ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"){ "EM_TI_C2000", "Texas Instruments TMS320C2000 DSP family", ELF ::EM_TI_C2000 }, | |||
1212 | ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"){ "EM_TI_C5500", "Texas Instruments TMS320C55x DSP family", ELF ::EM_TI_C5500 }, | |||
1213 | ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"){ "EM_MMDSP_PLUS", "STMicroelectronics 64bit VLIW Data Signal Processor" , ELF::EM_MMDSP_PLUS }, | |||
1214 | ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"){ "EM_CYPRESS_M8C", "Cypress M8C microprocessor", ELF::EM_CYPRESS_M8C }, | |||
1215 | ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"){ "EM_R32C", "Renesas R32C series microprocessors", ELF::EM_R32C }, | |||
1216 | ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"){ "EM_TRIMEDIA", "NXP Semiconductors TriMedia architecture family" , ELF::EM_TRIMEDIA }, | |||
1217 | ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"){ "EM_HEXAGON", "Qualcomm Hexagon", ELF::EM_HEXAGON }, | |||
1218 | ENUM_ENT(EM_8051, "Intel 8051 and variants"){ "EM_8051", "Intel 8051 and variants", ELF::EM_8051 }, | |||
1219 | ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"){ "EM_STXP7X", "STMicroelectronics STxP7x family", ELF::EM_STXP7X }, | |||
1220 | 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 }, | |||
1221 | ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"){ "EM_ECOG1", "Cyan Technology eCOG1 microprocessor", ELF::EM_ECOG1 }, | |||
1222 | // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has | |||
1223 | // an identical number to EM_ECOG1. | |||
1224 | ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"){ "EM_ECOG1X", "Cyan Technology eCOG1X family", ELF::EM_ECOG1X }, | |||
1225 | ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"){ "EM_MAXQ30", "Dallas Semiconductor MAXQ30 Core microcontrollers" , ELF::EM_MAXQ30 }, | |||
1226 | 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 }, | |||
1227 | ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"){ "EM_MANIK", "M2000 Reconfigurable RISC Microprocessor", ELF ::EM_MANIK }, | |||
1228 | ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"){ "EM_CRAYNV2", "Cray Inc. NV2 vector architecture", ELF::EM_CRAYNV2 }, | |||
1229 | ENUM_ENT(EM_RX, "Renesas RX"){ "EM_RX", "Renesas RX", ELF::EM_RX }, | |||
1230 | ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"){ "EM_METAG", "Imagination Technologies Meta processor architecture" , ELF::EM_METAG }, | |||
1231 | ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"){ "EM_MCST_ELBRUS", "MCST Elbrus general purpose hardware architecture" , ELF::EM_MCST_ELBRUS }, | |||
1232 | ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"){ "EM_ECOG16", "Cyan Technology eCOG16 family", ELF::EM_ECOG16 }, | |||
1233 | ENUM_ENT(EM_CR16, "National Semiconductor CompactRISC 16-bit processor"){ "EM_CR16", "National Semiconductor CompactRISC 16-bit processor" , ELF::EM_CR16 }, | |||
1234 | ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"){ "EM_ETPU", "Freescale Extended Time Processing Unit", ELF:: EM_ETPU }, | |||
1235 | ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"){ "EM_SLE9X", "Infineon Technologies SLE9X core", ELF::EM_SLE9X }, | |||
1236 | ENUM_ENT(EM_L10M, "EM_L10M"){ "EM_L10M", "EM_L10M", ELF::EM_L10M }, | |||
1237 | ENUM_ENT(EM_K10M, "EM_K10M"){ "EM_K10M", "EM_K10M", ELF::EM_K10M }, | |||
1238 | ENUM_ENT(EM_AARCH64, "AArch64"){ "EM_AARCH64", "AArch64", ELF::EM_AARCH64 }, | |||
1239 | ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"){ "EM_AVR32", "Atmel Corporation 32-bit microprocessor family" , ELF::EM_AVR32 }, | |||
1240 | ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"){ "EM_STM8", "STMicroeletronics STM8 8-bit microcontroller", ELF ::EM_STM8 }, | |||
1241 | ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"){ "EM_TILE64", "Tilera TILE64 multicore architecture family", ELF::EM_TILE64 }, | |||
1242 | ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"){ "EM_TILEPRO", "Tilera TILEPro multicore architecture family" , ELF::EM_TILEPRO }, | |||
1243 | 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 }, | |||
1244 | ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"){ "EM_CUDA", "NVIDIA CUDA architecture", ELF::EM_CUDA }, | |||
1245 | ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"){ "EM_TILEGX", "Tilera TILE-Gx multicore architecture family" , ELF::EM_TILEGX }, | |||
1246 | ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"){ "EM_CLOUDSHIELD", "EM_CLOUDSHIELD", ELF::EM_CLOUDSHIELD }, | |||
1247 | ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"){ "EM_COREA_1ST", "EM_COREA_1ST", ELF::EM_COREA_1ST }, | |||
1248 | ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"){ "EM_COREA_2ND", "EM_COREA_2ND", ELF::EM_COREA_2ND }, | |||
1249 | ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"){ "EM_ARC_COMPACT2", "EM_ARC_COMPACT2", ELF::EM_ARC_COMPACT2 }, | |||
1250 | ENUM_ENT(EM_OPEN8, "EM_OPEN8"){ "EM_OPEN8", "EM_OPEN8", ELF::EM_OPEN8 }, | |||
1251 | ENUM_ENT(EM_RL78, "Renesas RL78"){ "EM_RL78", "Renesas RL78", ELF::EM_RL78 }, | |||
1252 | ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"){ "EM_VIDEOCORE5", "Broadcom VideoCore V processor", ELF::EM_VIDEOCORE5 }, | |||
1253 | ENUM_ENT(EM_78KOR, "EM_78KOR"){ "EM_78KOR", "EM_78KOR", ELF::EM_78KOR }, | |||
1254 | ENUM_ENT(EM_56800EX, "EM_56800EX"){ "EM_56800EX", "EM_56800EX", ELF::EM_56800EX }, | |||
1255 | ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"){ "EM_AMDGPU", "EM_AMDGPU", ELF::EM_AMDGPU }, | |||
1256 | ENUM_ENT(EM_RISCV, "RISC-V"){ "EM_RISCV", "RISC-V", ELF::EM_RISCV }, | |||
1257 | ENUM_ENT(EM_LANAI, "EM_LANAI"){ "EM_LANAI", "EM_LANAI", ELF::EM_LANAI }, | |||
1258 | ENUM_ENT(EM_BPF, "EM_BPF"){ "EM_BPF", "EM_BPF", ELF::EM_BPF }, | |||
1259 | ENUM_ENT(EM_VE, "NEC SX-Aurora Vector Engine"){ "EM_VE", "NEC SX-Aurora Vector Engine", ELF::EM_VE }, | |||
1260 | ENUM_ENT(EM_LOONGARCH, "LoongArch"){ "EM_LOONGARCH", "LoongArch", ELF::EM_LOONGARCH }, | |||
1261 | }; | |||
1262 | ||||
1263 | const EnumEntry<unsigned> ElfSymbolBindings[] = { | |||
1264 | {"Local", "LOCAL", ELF::STB_LOCAL}, | |||
1265 | {"Global", "GLOBAL", ELF::STB_GLOBAL}, | |||
1266 | {"Weak", "WEAK", ELF::STB_WEAK}, | |||
1267 | {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; | |||
1268 | ||||
1269 | const EnumEntry<unsigned> ElfSymbolVisibilities[] = { | |||
1270 | {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, | |||
1271 | {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, | |||
1272 | {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, | |||
1273 | {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; | |||
1274 | ||||
1275 | const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { | |||
1276 | { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL } | |||
1277 | }; | |||
1278 | ||||
1279 | static const char *getGroupType(uint32_t Flag) { | |||
1280 | if (Flag & ELF::GRP_COMDAT) | |||
1281 | return "COMDAT"; | |||
1282 | else | |||
1283 | return "(unknown)"; | |||
1284 | } | |||
1285 | ||||
1286 | const EnumEntry<unsigned> ElfSectionFlags[] = { | |||
1287 | ENUM_ENT(SHF_WRITE, "W"){ "SHF_WRITE", "W", ELF::SHF_WRITE }, | |||
1288 | ENUM_ENT(SHF_ALLOC, "A"){ "SHF_ALLOC", "A", ELF::SHF_ALLOC }, | |||
1289 | ENUM_ENT(SHF_EXECINSTR, "X"){ "SHF_EXECINSTR", "X", ELF::SHF_EXECINSTR }, | |||
1290 | ENUM_ENT(SHF_MERGE, "M"){ "SHF_MERGE", "M", ELF::SHF_MERGE }, | |||
1291 | ENUM_ENT(SHF_STRINGS, "S"){ "SHF_STRINGS", "S", ELF::SHF_STRINGS }, | |||
1292 | ENUM_ENT(SHF_INFO_LINK, "I"){ "SHF_INFO_LINK", "I", ELF::SHF_INFO_LINK }, | |||
1293 | ENUM_ENT(SHF_LINK_ORDER, "L"){ "SHF_LINK_ORDER", "L", ELF::SHF_LINK_ORDER }, | |||
1294 | ENUM_ENT(SHF_OS_NONCONFORMING, "O"){ "SHF_OS_NONCONFORMING", "O", ELF::SHF_OS_NONCONFORMING }, | |||
1295 | ENUM_ENT(SHF_GROUP, "G"){ "SHF_GROUP", "G", ELF::SHF_GROUP }, | |||
1296 | ENUM_ENT(SHF_TLS, "T"){ "SHF_TLS", "T", ELF::SHF_TLS }, | |||
1297 | ENUM_ENT(SHF_COMPRESSED, "C"){ "SHF_COMPRESSED", "C", ELF::SHF_COMPRESSED }, | |||
1298 | ENUM_ENT(SHF_EXCLUDE, "E"){ "SHF_EXCLUDE", "E", ELF::SHF_EXCLUDE }, | |||
1299 | }; | |||
1300 | ||||
1301 | const EnumEntry<unsigned> ElfGNUSectionFlags[] = { | |||
1302 | ENUM_ENT(SHF_GNU_RETAIN, "R"){ "SHF_GNU_RETAIN", "R", ELF::SHF_GNU_RETAIN } | |||
1303 | }; | |||
1304 | ||||
1305 | const EnumEntry<unsigned> ElfSolarisSectionFlags[] = { | |||
1306 | ENUM_ENT(SHF_SUNW_NODISCARD, "R"){ "SHF_SUNW_NODISCARD", "R", ELF::SHF_SUNW_NODISCARD } | |||
1307 | }; | |||
1308 | ||||
1309 | const EnumEntry<unsigned> ElfXCoreSectionFlags[] = { | |||
1310 | ENUM_ENT(XCORE_SHF_CP_SECTION, ""){ "XCORE_SHF_CP_SECTION", "", ELF::XCORE_SHF_CP_SECTION }, | |||
1311 | ENUM_ENT(XCORE_SHF_DP_SECTION, ""){ "XCORE_SHF_DP_SECTION", "", ELF::XCORE_SHF_DP_SECTION } | |||
1312 | }; | |||
1313 | ||||
1314 | const EnumEntry<unsigned> ElfARMSectionFlags[] = { | |||
1315 | ENUM_ENT(SHF_ARM_PURECODE, "y"){ "SHF_ARM_PURECODE", "y", ELF::SHF_ARM_PURECODE } | |||
1316 | }; | |||
1317 | ||||
1318 | const EnumEntry<unsigned> ElfHexagonSectionFlags[] = { | |||
1319 | ENUM_ENT(SHF_HEX_GPREL, ""){ "SHF_HEX_GPREL", "", ELF::SHF_HEX_GPREL } | |||
1320 | }; | |||
1321 | ||||
1322 | const EnumEntry<unsigned> ElfMipsSectionFlags[] = { | |||
1323 | ENUM_ENT(SHF_MIPS_NODUPES, ""){ "SHF_MIPS_NODUPES", "", ELF::SHF_MIPS_NODUPES }, | |||
1324 | ENUM_ENT(SHF_MIPS_NAMES, ""){ "SHF_MIPS_NAMES", "", ELF::SHF_MIPS_NAMES }, | |||
1325 | ENUM_ENT(SHF_MIPS_LOCAL, ""){ "SHF_MIPS_LOCAL", "", ELF::SHF_MIPS_LOCAL }, | |||
1326 | ENUM_ENT(SHF_MIPS_NOSTRIP, ""){ "SHF_MIPS_NOSTRIP", "", ELF::SHF_MIPS_NOSTRIP }, | |||
1327 | ENUM_ENT(SHF_MIPS_GPREL, ""){ "SHF_MIPS_GPREL", "", ELF::SHF_MIPS_GPREL }, | |||
1328 | ENUM_ENT(SHF_MIPS_MERGE, ""){ "SHF_MIPS_MERGE", "", ELF::SHF_MIPS_MERGE }, | |||
1329 | ENUM_ENT(SHF_MIPS_ADDR, ""){ "SHF_MIPS_ADDR", "", ELF::SHF_MIPS_ADDR }, | |||
1330 | ENUM_ENT(SHF_MIPS_STRING, ""){ "SHF_MIPS_STRING", "", ELF::SHF_MIPS_STRING } | |||
1331 | }; | |||
1332 | ||||
1333 | const EnumEntry<unsigned> ElfX86_64SectionFlags[] = { | |||
1334 | ENUM_ENT(SHF_X86_64_LARGE, "l"){ "SHF_X86_64_LARGE", "l", ELF::SHF_X86_64_LARGE } | |||
1335 | }; | |||
1336 | ||||
1337 | static std::vector<EnumEntry<unsigned>> | |||
1338 | getSectionFlagsForTarget(unsigned EOSAbi, unsigned EMachine) { | |||
1339 | std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags), | |||
1340 | std::end(ElfSectionFlags)); | |||
1341 | switch (EOSAbi) { | |||
1342 | case ELFOSABI_SOLARIS: | |||
1343 | Ret.insert(Ret.end(), std::begin(ElfSolarisSectionFlags), | |||
1344 | std::end(ElfSolarisSectionFlags)); | |||
1345 | break; | |||
1346 | default: | |||
1347 | Ret.insert(Ret.end(), std::begin(ElfGNUSectionFlags), | |||
1348 | std::end(ElfGNUSectionFlags)); | |||
1349 | break; | |||
1350 | } | |||
1351 | switch (EMachine) { | |||
1352 | case EM_ARM: | |||
1353 | Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags), | |||
1354 | std::end(ElfARMSectionFlags)); | |||
1355 | break; | |||
1356 | case EM_HEXAGON: | |||
1357 | Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags), | |||
1358 | std::end(ElfHexagonSectionFlags)); | |||
1359 | break; | |||
1360 | case EM_MIPS: | |||
1361 | Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags), | |||
1362 | std::end(ElfMipsSectionFlags)); | |||
1363 | break; | |||
1364 | case EM_X86_64: | |||
1365 | Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags), | |||
1366 | std::end(ElfX86_64SectionFlags)); | |||
1367 | break; | |||
1368 | case EM_XCORE: | |||
1369 | Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags), | |||
1370 | std::end(ElfXCoreSectionFlags)); | |||
1371 | break; | |||
1372 | default: | |||
1373 | break; | |||
1374 | } | |||
1375 | return Ret; | |||
1376 | } | |||
1377 | ||||
1378 | static std::string getGNUFlags(unsigned EOSAbi, unsigned EMachine, | |||
1379 | uint64_t Flags) { | |||
1380 | // Here we are trying to build the flags string in the same way as GNU does. | |||
1381 | // It is not that straightforward. Imagine we have sh_flags == 0x90000000. | |||
1382 | // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000. | |||
1383 | // GNU readelf will not print "E" or "Ep" in this case, but will print just | |||
1384 | // "p". It only will print "E" when no other processor flag is set. | |||
1385 | std::string Str; | |||
1386 | bool HasUnknownFlag = false; | |||
1387 | bool HasOSFlag = false; | |||
1388 | bool HasProcFlag = false; | |||
1389 | std::vector<EnumEntry<unsigned>> FlagsList = | |||
1390 | getSectionFlagsForTarget(EOSAbi, EMachine); | |||
1391 | while (Flags) { | |||
1392 | // Take the least significant bit as a flag. | |||
1393 | uint64_t Flag = Flags & -Flags; | |||
1394 | Flags -= Flag; | |||
1395 | ||||
1396 | // Find the flag in the known flags list. | |||
1397 | auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) { | |||
1398 | // Flags with empty names are not printed in GNU style output. | |||
1399 | return E.Value == Flag && !E.AltName.empty(); | |||
1400 | }); | |||
1401 | if (I != FlagsList.end()) { | |||
1402 | Str += I->AltName; | |||
1403 | continue; | |||
1404 | } | |||
1405 | ||||
1406 | // If we did not find a matching regular flag, then we deal with an OS | |||
1407 | // specific flag, processor specific flag or an unknown flag. | |||
1408 | if (Flag & ELF::SHF_MASKOS) { | |||
1409 | HasOSFlag = true; | |||
1410 | Flags &= ~ELF::SHF_MASKOS; | |||
1411 | } else if (Flag & ELF::SHF_MASKPROC) { | |||
1412 | HasProcFlag = true; | |||
1413 | // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE | |||
1414 | // bit if set so that it doesn't also get printed. | |||
1415 | Flags &= ~ELF::SHF_MASKPROC; | |||
1416 | } else { | |||
1417 | HasUnknownFlag = true; | |||
1418 | } | |||
1419 | } | |||
1420 | ||||
1421 | // "o", "p" and "x" are printed last. | |||
1422 | if (HasOSFlag) | |||
1423 | Str += "o"; | |||
1424 | if (HasProcFlag) | |||
1425 | Str += "p"; | |||
1426 | if (HasUnknownFlag) | |||
1427 | Str += "x"; | |||
1428 | return Str; | |||
1429 | } | |||
1430 | ||||
1431 | static StringRef segmentTypeToString(unsigned Arch, unsigned Type) { | |||
1432 | // Check potentially overlapped processor-specific program header type. | |||
1433 | switch (Arch) { | |||
1434 | case ELF::EM_ARM: | |||
1435 | switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX)case ELF::PT_ARM_EXIDX: return "PT_ARM_EXIDX";; } | |||
1436 | break; | |||
1437 | case ELF::EM_MIPS: | |||
1438 | case ELF::EM_MIPS_RS3_LE: | |||
1439 | switch (Type) { | |||
1440 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO)case ELF::PT_MIPS_REGINFO: return "PT_MIPS_REGINFO";; | |||
1441 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC)case ELF::PT_MIPS_RTPROC: return "PT_MIPS_RTPROC";; | |||
1442 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS)case ELF::PT_MIPS_OPTIONS: return "PT_MIPS_OPTIONS";; | |||
1443 | LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS)case ELF::PT_MIPS_ABIFLAGS: return "PT_MIPS_ABIFLAGS";; | |||
1444 | } | |||
1445 | break; | |||
1446 | case ELF::EM_RISCV: | |||
1447 | switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_RISCV_ATTRIBUTES)case ELF::PT_RISCV_ATTRIBUTES: return "PT_RISCV_ATTRIBUTES";; } | |||
1448 | } | |||
1449 | ||||
1450 | switch (Type) { | |||
1451 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL)case ELF::PT_NULL: return "PT_NULL";; | |||
1452 | LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD)case ELF::PT_LOAD: return "PT_LOAD";; | |||
1453 | LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC)case ELF::PT_DYNAMIC: return "PT_DYNAMIC";; | |||
1454 | LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP)case ELF::PT_INTERP: return "PT_INTERP";; | |||
1455 | LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE)case ELF::PT_NOTE: return "PT_NOTE";; | |||
1456 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB)case ELF::PT_SHLIB: return "PT_SHLIB";; | |||
1457 | LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR)case ELF::PT_PHDR: return "PT_PHDR";; | |||
1458 | LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS)case ELF::PT_TLS: return "PT_TLS";; | |||
1459 | ||||
1460 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME)case ELF::PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME";; | |||
1461 | LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND)case ELF::PT_SUNW_UNWIND: return "PT_SUNW_UNWIND";; | |||
1462 | ||||
1463 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK)case ELF::PT_GNU_STACK: return "PT_GNU_STACK";; | |||
1464 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO)case ELF::PT_GNU_RELRO: return "PT_GNU_RELRO";; | |||
1465 | LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_PROPERTY)case ELF::PT_GNU_PROPERTY: return "PT_GNU_PROPERTY";; | |||
1466 | ||||
1467 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_MUTABLE)case ELF::PT_OPENBSD_MUTABLE: return "PT_OPENBSD_MUTABLE";; | |||
1468 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE)case ELF::PT_OPENBSD_RANDOMIZE: return "PT_OPENBSD_RANDOMIZE" ;; | |||
1469 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED)case ELF::PT_OPENBSD_WXNEEDED: return "PT_OPENBSD_WXNEEDED";; | |||
1470 | LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA)case ELF::PT_OPENBSD_BOOTDATA: return "PT_OPENBSD_BOOTDATA";; | |||
1471 | default: | |||
1472 | return ""; | |||
1473 | } | |||
1474 | } | |||
1475 | ||||
1476 | static std::string getGNUPtType(unsigned Arch, unsigned Type) { | |||
1477 | StringRef Seg = segmentTypeToString(Arch, Type); | |||
1478 | if (Seg.empty()) | |||
1479 | return std::string("<unknown>: ") + to_string(format_hex(Type, 1)); | |||
1480 | ||||
1481 | // E.g. "PT_ARM_EXIDX" -> "EXIDX". | |||
1482 | if (Seg.consume_front("PT_ARM_")) | |||
1483 | return Seg.str(); | |||
1484 | ||||
1485 | // E.g. "PT_MIPS_REGINFO" -> "REGINFO". | |||
1486 | if (Seg.consume_front("PT_MIPS_")) | |||
1487 | return Seg.str(); | |||
1488 | ||||
1489 | // E.g. "PT_RISCV_ATTRIBUTES" | |||
1490 | if (Seg.consume_front("PT_RISCV_")) | |||
1491 | return Seg.str(); | |||
1492 | ||||
1493 | // E.g. "PT_LOAD" -> "LOAD". | |||
1494 | assert(Seg.startswith("PT_"))(static_cast <bool> (Seg.startswith("PT_")) ? void (0) : __assert_fail ("Seg.startswith(\"PT_\")", "llvm/tools/llvm-readobj/ELFDumper.cpp" , 1494, __extension__ __PRETTY_FUNCTION__)); | |||
1495 | return Seg.drop_front(3).str(); | |||
1496 | } | |||
1497 | ||||
1498 | const EnumEntry<unsigned> ElfSegmentFlags[] = { | |||
1499 | LLVM_READOBJ_ENUM_ENT(ELF, PF_X){ "PF_X", ELF::PF_X }, | |||
1500 | LLVM_READOBJ_ENUM_ENT(ELF, PF_W){ "PF_W", ELF::PF_W }, | |||
1501 | LLVM_READOBJ_ENUM_ENT(ELF, PF_R){ "PF_R", ELF::PF_R } | |||
1502 | }; | |||
1503 | ||||
1504 | const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { | |||
1505 | ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"){ "EF_MIPS_NOREORDER", "noreorder", ELF::EF_MIPS_NOREORDER }, | |||
1506 | ENUM_ENT(EF_MIPS_PIC, "pic"){ "EF_MIPS_PIC", "pic", ELF::EF_MIPS_PIC }, | |||
1507 | ENUM_ENT(EF_MIPS_CPIC, "cpic"){ "EF_MIPS_CPIC", "cpic", ELF::EF_MIPS_CPIC }, | |||
1508 | ENUM_ENT(EF_MIPS_ABI2, "abi2"){ "EF_MIPS_ABI2", "abi2", ELF::EF_MIPS_ABI2 }, | |||
1509 | ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"){ "EF_MIPS_32BITMODE", "32bitmode", ELF::EF_MIPS_32BITMODE }, | |||
1510 | ENUM_ENT(EF_MIPS_FP64, "fp64"){ "EF_MIPS_FP64", "fp64", ELF::EF_MIPS_FP64 }, | |||
1511 | ENUM_ENT(EF_MIPS_NAN2008, "nan2008"){ "EF_MIPS_NAN2008", "nan2008", ELF::EF_MIPS_NAN2008 }, | |||
1512 | ENUM_ENT(EF_MIPS_ABI_O32, "o32"){ "EF_MIPS_ABI_O32", "o32", ELF::EF_MIPS_ABI_O32 }, | |||
1513 | ENUM_ENT(EF_MIPS_ABI_O64, "o64"){ "EF_MIPS_ABI_O64", "o64", ELF::EF_MIPS_ABI_O64 }, | |||
1514 | ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"){ "EF_MIPS_ABI_EABI32", "eabi32", ELF::EF_MIPS_ABI_EABI32 }, | |||
1515 | ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"){ "EF_MIPS_ABI_EABI64", "eabi64", ELF::EF_MIPS_ABI_EABI64 }, | |||
1516 | ENUM_ENT(EF_MIPS_MACH_3900, "3900"){ "EF_MIPS_MACH_3900", "3900", ELF::EF_MIPS_MACH_3900 }, | |||
1517 | ENUM_ENT(EF_MIPS_MACH_4010, "4010"){ "EF_MIPS_MACH_4010", "4010", ELF::EF_MIPS_MACH_4010 }, | |||
1518 | ENUM_ENT(EF_MIPS_MACH_4100, "4100"){ "EF_MIPS_MACH_4100", "4100", ELF::EF_MIPS_MACH_4100 }, | |||
1519 | ENUM_ENT(EF_MIPS_MACH_4650, "4650"){ "EF_MIPS_MACH_4650", "4650", ELF::EF_MIPS_MACH_4650 }, | |||
1520 | ENUM_ENT(EF_MIPS_MACH_4120, "4120"){ "EF_MIPS_MACH_4120", "4120", ELF::EF_MIPS_MACH_4120 }, | |||
1521 | ENUM_ENT(EF_MIPS_MACH_4111, "4111"){ "EF_MIPS_MACH_4111", "4111", ELF::EF_MIPS_MACH_4111 }, | |||
1522 | ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"){ "EF_MIPS_MACH_SB1", "sb1", ELF::EF_MIPS_MACH_SB1 }, | |||
1523 | ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"){ "EF_MIPS_MACH_OCTEON", "octeon", ELF::EF_MIPS_MACH_OCTEON }, | |||
1524 | ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"){ "EF_MIPS_MACH_XLR", "xlr", ELF::EF_MIPS_MACH_XLR }, | |||
1525 | ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"){ "EF_MIPS_MACH_OCTEON2", "octeon2", ELF::EF_MIPS_MACH_OCTEON2 }, | |||
1526 | ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"){ "EF_MIPS_MACH_OCTEON3", "octeon3", ELF::EF_MIPS_MACH_OCTEON3 }, | |||
1527 | ENUM_ENT(EF_MIPS_MACH_5400, "5400"){ "EF_MIPS_MACH_5400", "5400", ELF::EF_MIPS_MACH_5400 }, | |||
1528 | ENUM_ENT(EF_MIPS_MACH_5900, "5900"){ "EF_MIPS_MACH_5900", "5900", ELF::EF_MIPS_MACH_5900 }, | |||
1529 | ENUM_ENT(EF_MIPS_MACH_5500, "5500"){ "EF_MIPS_MACH_5500", "5500", ELF::EF_MIPS_MACH_5500 }, | |||
1530 | ENUM_ENT(EF_MIPS_MACH_9000, "9000"){ "EF_MIPS_MACH_9000", "9000", ELF::EF_MIPS_MACH_9000 }, | |||
1531 | ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"){ "EF_MIPS_MACH_LS2E", "loongson-2e", ELF::EF_MIPS_MACH_LS2E }, | |||
1532 | ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"){ "EF_MIPS_MACH_LS2F", "loongson-2f", ELF::EF_MIPS_MACH_LS2F }, | |||
1533 | ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"){ "EF_MIPS_MACH_LS3A", "loongson-3a", ELF::EF_MIPS_MACH_LS3A }, | |||
1534 | ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"){ "EF_MIPS_MICROMIPS", "micromips", ELF::EF_MIPS_MICROMIPS }, | |||
1535 | ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"){ "EF_MIPS_ARCH_ASE_M16", "mips16", ELF::EF_MIPS_ARCH_ASE_M16 }, | |||
1536 | ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"){ "EF_MIPS_ARCH_ASE_MDMX", "mdmx", ELF::EF_MIPS_ARCH_ASE_MDMX }, | |||
1537 | ENUM_ENT(EF_MIPS_ARCH_1, "mips1"){ "EF_MIPS_ARCH_1", "mips1", ELF::EF_MIPS_ARCH_1 }, | |||
1538 | ENUM_ENT(EF_MIPS_ARCH_2, "mips2"){ "EF_MIPS_ARCH_2", "mips2", ELF::EF_MIPS_ARCH_2 }, | |||
1539 | ENUM_ENT(EF_MIPS_ARCH_3, "mips3"){ "EF_MIPS_ARCH_3", "mips3", ELF::EF_MIPS_ARCH_3 }, | |||
1540 | ENUM_ENT(EF_MIPS_ARCH_4, "mips4"){ "EF_MIPS_ARCH_4", "mips4", ELF::EF_MIPS_ARCH_4 }, | |||
1541 | ENUM_ENT(EF_MIPS_ARCH_5, "mips5"){ "EF_MIPS_ARCH_5", "mips5", ELF::EF_MIPS_ARCH_5 }, | |||
1542 | ENUM_ENT(EF_MIPS_ARCH_32, "mips32"){ "EF_MIPS_ARCH_32", "mips32", ELF::EF_MIPS_ARCH_32 }, | |||
1543 | ENUM_ENT(EF_MIPS_ARCH_64, "mips64"){ "EF_MIPS_ARCH_64", "mips64", ELF::EF_MIPS_ARCH_64 }, | |||
1544 | ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"){ "EF_MIPS_ARCH_32R2", "mips32r2", ELF::EF_MIPS_ARCH_32R2 }, | |||
1545 | ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"){ "EF_MIPS_ARCH_64R2", "mips64r2", ELF::EF_MIPS_ARCH_64R2 }, | |||
1546 | ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"){ "EF_MIPS_ARCH_32R6", "mips32r6", ELF::EF_MIPS_ARCH_32R6 }, | |||
1547 | ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6"){ "EF_MIPS_ARCH_64R6", "mips64r6", ELF::EF_MIPS_ARCH_64R6 } | |||
1548 | }; | |||
1549 | ||||
1550 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion3[] = { | |||
1551 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1552 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1553 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1554 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1555 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1556 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1557 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1558 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1559 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1560 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1561 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1562 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1563 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1564 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1565 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1566 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1567 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1568 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1569 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1570 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1571 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1572 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1573 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1574 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1575 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1576 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1577 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1578 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1579 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1580 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1581 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1582 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1583 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1584 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1585 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1586 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1587 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1588 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1589 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1590 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1591 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1592 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1593 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1594 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1595 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1596 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1597 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1598 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1599 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1600 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1601 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1602 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1100){ "EF_AMDGPU_MACH_AMDGCN_GFX1100", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100 }, | |||
1603 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1101){ "EF_AMDGPU_MACH_AMDGCN_GFX1101", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101 }, | |||
1604 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1102){ "EF_AMDGPU_MACH_AMDGCN_GFX1102", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102 }, | |||
1605 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1103){ "EF_AMDGPU_MACH_AMDGCN_GFX1103", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103 }, | |||
1606 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_V3){ "EF_AMDGPU_FEATURE_XNACK_V3", ELF::EF_AMDGPU_FEATURE_XNACK_V3 }, | |||
1607 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_V3){ "EF_AMDGPU_FEATURE_SRAMECC_V3", ELF::EF_AMDGPU_FEATURE_SRAMECC_V3 } | |||
1608 | }; | |||
1609 | ||||
1610 | const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion4[] = { | |||
1611 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE){ "EF_AMDGPU_MACH_NONE", ELF::EF_AMDGPU_MACH_NONE }, | |||
1612 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600){ "EF_AMDGPU_MACH_R600_R600", ELF::EF_AMDGPU_MACH_R600_R600 }, | |||
1613 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630){ "EF_AMDGPU_MACH_R600_R630", ELF::EF_AMDGPU_MACH_R600_R630 }, | |||
1614 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880){ "EF_AMDGPU_MACH_R600_RS880", ELF::EF_AMDGPU_MACH_R600_RS880 }, | |||
1615 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670){ "EF_AMDGPU_MACH_R600_RV670", ELF::EF_AMDGPU_MACH_R600_RV670 }, | |||
1616 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710){ "EF_AMDGPU_MACH_R600_RV710", ELF::EF_AMDGPU_MACH_R600_RV710 }, | |||
1617 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730){ "EF_AMDGPU_MACH_R600_RV730", ELF::EF_AMDGPU_MACH_R600_RV730 }, | |||
1618 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770){ "EF_AMDGPU_MACH_R600_RV770", ELF::EF_AMDGPU_MACH_R600_RV770 }, | |||
1619 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR){ "EF_AMDGPU_MACH_R600_CEDAR", ELF::EF_AMDGPU_MACH_R600_CEDAR }, | |||
1620 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS){ "EF_AMDGPU_MACH_R600_CYPRESS", ELF::EF_AMDGPU_MACH_R600_CYPRESS }, | |||
1621 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER){ "EF_AMDGPU_MACH_R600_JUNIPER", ELF::EF_AMDGPU_MACH_R600_JUNIPER }, | |||
1622 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD){ "EF_AMDGPU_MACH_R600_REDWOOD", ELF::EF_AMDGPU_MACH_R600_REDWOOD }, | |||
1623 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO){ "EF_AMDGPU_MACH_R600_SUMO", ELF::EF_AMDGPU_MACH_R600_SUMO }, | |||
1624 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS){ "EF_AMDGPU_MACH_R600_BARTS", ELF::EF_AMDGPU_MACH_R600_BARTS }, | |||
1625 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS){ "EF_AMDGPU_MACH_R600_CAICOS", ELF::EF_AMDGPU_MACH_R600_CAICOS }, | |||
1626 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN){ "EF_AMDGPU_MACH_R600_CAYMAN", ELF::EF_AMDGPU_MACH_R600_CAYMAN }, | |||
1627 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS){ "EF_AMDGPU_MACH_R600_TURKS", ELF::EF_AMDGPU_MACH_R600_TURKS }, | |||
1628 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600){ "EF_AMDGPU_MACH_AMDGCN_GFX600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 }, | |||
1629 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601){ "EF_AMDGPU_MACH_AMDGCN_GFX601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 }, | |||
1630 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602){ "EF_AMDGPU_MACH_AMDGCN_GFX602", ELF::EF_AMDGPU_MACH_AMDGCN_GFX602 }, | |||
1631 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700){ "EF_AMDGPU_MACH_AMDGCN_GFX700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 }, | |||
1632 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701){ "EF_AMDGPU_MACH_AMDGCN_GFX701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 }, | |||
1633 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702){ "EF_AMDGPU_MACH_AMDGCN_GFX702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 }, | |||
1634 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703){ "EF_AMDGPU_MACH_AMDGCN_GFX703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 }, | |||
1635 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704){ "EF_AMDGPU_MACH_AMDGCN_GFX704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 }, | |||
1636 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705){ "EF_AMDGPU_MACH_AMDGCN_GFX705", ELF::EF_AMDGPU_MACH_AMDGCN_GFX705 }, | |||
1637 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801){ "EF_AMDGPU_MACH_AMDGCN_GFX801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 }, | |||
1638 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802){ "EF_AMDGPU_MACH_AMDGCN_GFX802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 }, | |||
1639 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803){ "EF_AMDGPU_MACH_AMDGCN_GFX803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 }, | |||
1640 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805){ "EF_AMDGPU_MACH_AMDGCN_GFX805", ELF::EF_AMDGPU_MACH_AMDGCN_GFX805 }, | |||
1641 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810){ "EF_AMDGPU_MACH_AMDGCN_GFX810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 }, | |||
1642 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900){ "EF_AMDGPU_MACH_AMDGCN_GFX900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 }, | |||
1643 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902){ "EF_AMDGPU_MACH_AMDGCN_GFX902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 }, | |||
1644 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904){ "EF_AMDGPU_MACH_AMDGCN_GFX904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 }, | |||
1645 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906){ "EF_AMDGPU_MACH_AMDGCN_GFX906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 }, | |||
1646 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908){ "EF_AMDGPU_MACH_AMDGCN_GFX908", ELF::EF_AMDGPU_MACH_AMDGCN_GFX908 }, | |||
1647 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909){ "EF_AMDGPU_MACH_AMDGCN_GFX909", ELF::EF_AMDGPU_MACH_AMDGCN_GFX909 }, | |||
1648 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A){ "EF_AMDGPU_MACH_AMDGCN_GFX90A", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A }, | |||
1649 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C){ "EF_AMDGPU_MACH_AMDGCN_GFX90C", ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C }, | |||
1650 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940){ "EF_AMDGPU_MACH_AMDGCN_GFX940", ELF::EF_AMDGPU_MACH_AMDGCN_GFX940 }, | |||
1651 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010){ "EF_AMDGPU_MACH_AMDGCN_GFX1010", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010 }, | |||
1652 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011){ "EF_AMDGPU_MACH_AMDGCN_GFX1011", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011 }, | |||
1653 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012){ "EF_AMDGPU_MACH_AMDGCN_GFX1012", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012 }, | |||
1654 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013){ "EF_AMDGPU_MACH_AMDGCN_GFX1013", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013 }, | |||
1655 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030){ "EF_AMDGPU_MACH_AMDGCN_GFX1030", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030 }, | |||
1656 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031){ "EF_AMDGPU_MACH_AMDGCN_GFX1031", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031 }, | |||
1657 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032){ "EF_AMDGPU_MACH_AMDGCN_GFX1032", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032 }, | |||
1658 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033){ "EF_AMDGPU_MACH_AMDGCN_GFX1033", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033 }, | |||
1659 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034){ "EF_AMDGPU_MACH_AMDGCN_GFX1034", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034 }, | |||
1660 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035){ "EF_AMDGPU_MACH_AMDGCN_GFX1035", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035 }, | |||
1661 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036){ "EF_AMDGPU_MACH_AMDGCN_GFX1036", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036 }, | |||
1662 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1100){ "EF_AMDGPU_MACH_AMDGCN_GFX1100", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100 }, | |||
1663 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1101){ "EF_AMDGPU_MACH_AMDGCN_GFX1101", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101 }, | |||
1664 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1102){ "EF_AMDGPU_MACH_AMDGCN_GFX1102", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102 }, | |||
1665 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1103){ "EF_AMDGPU_MACH_AMDGCN_GFX1103", ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103 }, | |||
1666 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ANY_V4){ "EF_AMDGPU_FEATURE_XNACK_ANY_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4 }, | |||
1667 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_OFF_V4){ "EF_AMDGPU_FEATURE_XNACK_OFF_V4", ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4 }, | |||
1668 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ON_V4){ "EF_AMDGPU_FEATURE_XNACK_ON_V4", ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4 }, | |||
1669 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ANY_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ANY_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4 }, | |||
1670 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_OFF_V4){ "EF_AMDGPU_FEATURE_SRAMECC_OFF_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4 }, | |||
1671 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ON_V4){ "EF_AMDGPU_FEATURE_SRAMECC_ON_V4", ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4 } | |||
1672 | }; | |||
1673 | ||||
1674 | const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = { | |||
1675 | ENUM_ENT(EF_RISCV_RVC, "RVC"){ "EF_RISCV_RVC", "RVC", ELF::EF_RISCV_RVC }, | |||
1676 | ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"){ "EF_RISCV_FLOAT_ABI_SINGLE", "single-float ABI", ELF::EF_RISCV_FLOAT_ABI_SINGLE }, | |||
1677 | ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"){ "EF_RISCV_FLOAT_ABI_DOUBLE", "double-float ABI", ELF::EF_RISCV_FLOAT_ABI_DOUBLE }, | |||
1678 | ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"){ "EF_RISCV_FLOAT_ABI_QUAD", "quad-float ABI", ELF::EF_RISCV_FLOAT_ABI_QUAD }, | |||
1679 | ENUM_ENT(EF_RISCV_RVE, "RVE"){ "EF_RISCV_RVE", "RVE", ELF::EF_RISCV_RVE }, | |||
1680 | ENUM_ENT(EF_RISCV_TSO, "TSO"){ "EF_RISCV_TSO", "TSO", ELF::EF_RISCV_TSO }, | |||
1681 | }; | |||
1682 | ||||
1683 | const EnumEntry<unsigned> ElfHeaderAVRFlags[] = { | |||
1684 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR1){ "EF_AVR_ARCH_AVR1", ELF::EF_AVR_ARCH_AVR1 }, | |||
1685 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR2){ "EF_AVR_ARCH_AVR2", ELF::EF_AVR_ARCH_AVR2 }, | |||
1686 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR25){ "EF_AVR_ARCH_AVR25", ELF::EF_AVR_ARCH_AVR25 }, | |||
1687 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR3){ "EF_AVR_ARCH_AVR3", ELF::EF_AVR_ARCH_AVR3 }, | |||
1688 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR31){ "EF_AVR_ARCH_AVR31", ELF::EF_AVR_ARCH_AVR31 }, | |||
1689 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR35){ "EF_AVR_ARCH_AVR35", ELF::EF_AVR_ARCH_AVR35 }, | |||
1690 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR4){ "EF_AVR_ARCH_AVR4", ELF::EF_AVR_ARCH_AVR4 }, | |||
1691 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR5){ "EF_AVR_ARCH_AVR5", ELF::EF_AVR_ARCH_AVR5 }, | |||
1692 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR51){ "EF_AVR_ARCH_AVR51", ELF::EF_AVR_ARCH_AVR51 }, | |||
1693 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR6){ "EF_AVR_ARCH_AVR6", ELF::EF_AVR_ARCH_AVR6 }, | |||
1694 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVRTINY){ "EF_AVR_ARCH_AVRTINY", ELF::EF_AVR_ARCH_AVRTINY }, | |||
1695 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA1){ "EF_AVR_ARCH_XMEGA1", ELF::EF_AVR_ARCH_XMEGA1 }, | |||
1696 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA2){ "EF_AVR_ARCH_XMEGA2", ELF::EF_AVR_ARCH_XMEGA2 }, | |||
1697 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3){ "EF_AVR_ARCH_XMEGA3", ELF::EF_AVR_ARCH_XMEGA3 }, | |||
1698 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4){ "EF_AVR_ARCH_XMEGA4", ELF::EF_AVR_ARCH_XMEGA4 }, | |||
1699 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5){ "EF_AVR_ARCH_XMEGA5", ELF::EF_AVR_ARCH_XMEGA5 }, | |||
1700 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6){ "EF_AVR_ARCH_XMEGA6", ELF::EF_AVR_ARCH_XMEGA6 }, | |||
1701 | LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7){ "EF_AVR_ARCH_XMEGA7", ELF::EF_AVR_ARCH_XMEGA7 }, | |||
1702 | ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"){ "EF_AVR_LINKRELAX_PREPARED", "relaxable", ELF::EF_AVR_LINKRELAX_PREPARED }, | |||
1703 | }; | |||
1704 | ||||
1705 | const EnumEntry<unsigned> ElfHeaderLoongArchFlags[] = { | |||
1706 | ENUM_ENT(EF_LOONGARCH_ABI_SOFT_FLOAT, "SOFT-FLOAT"){ "EF_LOONGARCH_ABI_SOFT_FLOAT", "SOFT-FLOAT", ELF::EF_LOONGARCH_ABI_SOFT_FLOAT }, | |||
1707 | ENUM_ENT(EF_LOONGARCH_ABI_SINGLE_FLOAT, "SINGLE-FLOAT"){ "EF_LOONGARCH_ABI_SINGLE_FLOAT", "SINGLE-FLOAT", ELF::EF_LOONGARCH_ABI_SINGLE_FLOAT }, | |||
1708 | ENUM_ENT(EF_LOONGARCH_ABI_DOUBLE_FLOAT, "DOUBLE-FLOAT"){ "EF_LOONGARCH_ABI_DOUBLE_FLOAT", "DOUBLE-FLOAT", ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT }, | |||
1709 | ENUM_ENT(EF_LOONGARCH_OBJABI_V0, "OBJ-v0"){ "EF_LOONGARCH_OBJABI_V0", "OBJ-v0", ELF::EF_LOONGARCH_OBJABI_V0 }, | |||
1710 | ENUM_ENT(EF_LOONGARCH_OBJABI_V1, "OBJ-v1"){ "EF_LOONGARCH_OBJABI_V1", "OBJ-v1", ELF::EF_LOONGARCH_OBJABI_V1 }, | |||
1711 | }; | |||
1712 | ||||
1713 | static const EnumEntry<unsigned> ElfHeaderXtensaFlags[] = { | |||
1714 | LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_MACH_NONE){ "EF_XTENSA_MACH_NONE", ELF::EF_XTENSA_MACH_NONE }, | |||
1715 | LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_XT_INSN){ "EF_XTENSA_XT_INSN", ELF::EF_XTENSA_XT_INSN }, | |||
1716 | LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_XT_LIT){ "EF_XTENSA_XT_LIT", ELF::EF_XTENSA_XT_LIT } | |||
1717 | }; | |||
1718 | ||||
1719 | const EnumEntry<unsigned> ElfSymOtherFlags[] = { | |||
1720 | LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL){ "STV_INTERNAL", ELF::STV_INTERNAL }, | |||
1721 | LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN){ "STV_HIDDEN", ELF::STV_HIDDEN }, | |||
1722 | LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED){ "STV_PROTECTED", ELF::STV_PROTECTED } | |||
1723 | }; | |||
1724 | ||||
1725 | const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = { | |||
1726 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1727 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1728 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC){ "STO_MIPS_PIC", ELF::STO_MIPS_PIC }, | |||
1729 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS){ "STO_MIPS_MICROMIPS", ELF::STO_MIPS_MICROMIPS } | |||
1730 | }; | |||
1731 | ||||
1732 | const EnumEntry<unsigned> ElfAArch64SymOtherFlags[] = { | |||
1733 | LLVM_READOBJ_ENUM_ENT(ELF, STO_AARCH64_VARIANT_PCS){ "STO_AARCH64_VARIANT_PCS", ELF::STO_AARCH64_VARIANT_PCS } | |||
1734 | }; | |||
1735 | ||||
1736 | const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = { | |||
1737 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL){ "STO_MIPS_OPTIONAL", ELF::STO_MIPS_OPTIONAL }, | |||
1738 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT){ "STO_MIPS_PLT", ELF::STO_MIPS_PLT }, | |||
1739 | LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16){ "STO_MIPS_MIPS16", ELF::STO_MIPS_MIPS16 } | |||
1740 | }; | |||
1741 | ||||
1742 | const EnumEntry<unsigned> ElfRISCVSymOtherFlags[] = { | |||
1743 | LLVM_READOBJ_ENUM_ENT(ELF, STO_RISCV_VARIANT_CC){ "STO_RISCV_VARIANT_CC", ELF::STO_RISCV_VARIANT_CC }}; | |||
1744 | ||||
1745 | static const char *getElfMipsOptionsOdkType(unsigned Odk) { | |||
1746 | switch (Odk) { | |||
1747 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL)case ELF::ODK_NULL: return "ODK_NULL";; | |||
1748 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO)case ELF::ODK_REGINFO: return "ODK_REGINFO";; | |||
1749 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS)case ELF::ODK_EXCEPTIONS: return "ODK_EXCEPTIONS";; | |||
1750 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD)case ELF::ODK_PAD: return "ODK_PAD";; | |||
1751 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH)case ELF::ODK_HWPATCH: return "ODK_HWPATCH";; | |||
1752 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL)case ELF::ODK_FILL: return "ODK_FILL";; | |||
1753 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS)case ELF::ODK_TAGS: return "ODK_TAGS";; | |||
1754 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND)case ELF::ODK_HWAND: return "ODK_HWAND";; | |||
1755 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR)case ELF::ODK_HWOR: return "ODK_HWOR";; | |||
1756 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP)case ELF::ODK_GP_GROUP: return "ODK_GP_GROUP";; | |||
1757 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT)case ELF::ODK_IDENT: return "ODK_IDENT";; | |||
1758 | LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE)case ELF::ODK_PAGESIZE: return "ODK_PAGESIZE";; | |||
1759 | default: | |||
1760 | return "Unknown"; | |||
1761 | } | |||
1762 | } | |||
1763 | ||||
1764 | template <typename ELFT> | |||
1765 | std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *> | |||
1766 | ELFDumper<ELFT>::findDynamic() { | |||
1767 | // Try to locate the PT_DYNAMIC header. | |||
1768 | const Elf_Phdr *DynamicPhdr = nullptr; | |||
1769 | if (Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj.program_headers()) { | |||
1770 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
1771 | if (Phdr.p_type != ELF::PT_DYNAMIC) | |||
1772 | continue; | |||
1773 | DynamicPhdr = &Phdr; | |||
1774 | break; | |||
1775 | } | |||
1776 | } else { | |||
1777 | reportUniqueWarning( | |||
1778 | "unable to read program headers to locate the PT_DYNAMIC segment: " + | |||
1779 | toString(PhdrsOrErr.takeError())); | |||
1780 | } | |||
1781 | ||||
1782 | // Try to locate the .dynamic section in the sections header table. | |||
1783 | const Elf_Shdr *DynamicSec = nullptr; | |||
1784 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
1785 | if (Sec.sh_type != ELF::SHT_DYNAMIC) | |||
1786 | continue; | |||
1787 | DynamicSec = &Sec; | |||
1788 | break; | |||
1789 | } | |||
1790 | ||||
1791 | if (DynamicPhdr && ((DynamicPhdr->p_offset + DynamicPhdr->p_filesz > | |||
1792 | ObjF.getMemoryBufferRef().getBufferSize()) || | |||
1793 | (DynamicPhdr->p_offset + DynamicPhdr->p_filesz < | |||
1794 | DynamicPhdr->p_offset))) { | |||
1795 | reportUniqueWarning( | |||
1796 | "PT_DYNAMIC segment offset (0x" + | |||
1797 | Twine::utohexstr(DynamicPhdr->p_offset) + ") + file size (0x" + | |||
1798 | Twine::utohexstr(DynamicPhdr->p_filesz) + | |||
1799 | ") exceeds the size of the file (0x" + | |||
1800 | Twine::utohexstr(ObjF.getMemoryBufferRef().getBufferSize()) + ")"); | |||
1801 | // Don't use the broken dynamic header. | |||
1802 | DynamicPhdr = nullptr; | |||
1803 | } | |||
1804 | ||||
1805 | if (DynamicPhdr && DynamicSec) { | |||
1806 | if (DynamicSec->sh_addr + DynamicSec->sh_size > | |||
1807 | DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz || | |||
1808 | DynamicSec->sh_addr < DynamicPhdr->p_vaddr) | |||
1809 | reportUniqueWarning(describe(*DynamicSec) + | |||
1810 | " is not contained within the " | |||
1811 | "PT_DYNAMIC segment"); | |||
1812 | ||||
1813 | if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr) | |||
1814 | reportUniqueWarning(describe(*DynamicSec) + " is not at the start of " | |||
1815 | "PT_DYNAMIC segment"); | |||
1816 | } | |||
1817 | ||||
1818 | return std::make_pair(DynamicPhdr, DynamicSec); | |||
1819 | } | |||
1820 | ||||
1821 | template <typename ELFT> | |||
1822 | void ELFDumper<ELFT>::loadDynamicTable() { | |||
1823 | const Elf_Phdr *DynamicPhdr; | |||
1824 | const Elf_Shdr *DynamicSec; | |||
1825 | std::tie(DynamicPhdr, DynamicSec) = findDynamic(); | |||
1826 | if (!DynamicPhdr && !DynamicSec) | |||
1827 | return; | |||
1828 | ||||
1829 | DynRegionInfo FromPhdr(ObjF, *this); | |||
1830 | bool IsPhdrTableValid = false; | |||
1831 | if (DynamicPhdr) { | |||
1832 | // Use cantFail(), because p_offset/p_filesz fields of a PT_DYNAMIC are | |||
1833 | // validated in findDynamic() and so createDRI() is not expected to fail. | |||
1834 | FromPhdr = cantFail(createDRI(DynamicPhdr->p_offset, DynamicPhdr->p_filesz, | |||
1835 | sizeof(Elf_Dyn))); | |||
1836 | FromPhdr.SizePrintName = "PT_DYNAMIC size"; | |||
1837 | FromPhdr.EntSizePrintName = ""; | |||
1838 | IsPhdrTableValid = !FromPhdr.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1839 | } | |||
1840 | ||||
1841 | // Locate the dynamic table described in a section header. | |||
1842 | // Ignore sh_entsize and use the expected value for entry size explicitly. | |||
1843 | // This allows us to dump dynamic sections with a broken sh_entsize | |||
1844 | // field. | |||
1845 | DynRegionInfo FromSec(ObjF, *this); | |||
1846 | bool IsSecTableValid = false; | |||
1847 | if (DynamicSec) { | |||
1848 | Expected<DynRegionInfo> RegOrErr = | |||
1849 | createDRI(DynamicSec->sh_offset, DynamicSec->sh_size, sizeof(Elf_Dyn)); | |||
1850 | if (RegOrErr) { | |||
1851 | FromSec = *RegOrErr; | |||
1852 | FromSec.Context = describe(*DynamicSec); | |||
1853 | FromSec.EntSizePrintName = ""; | |||
1854 | IsSecTableValid = !FromSec.template getAsArrayRef<Elf_Dyn>().empty(); | |||
1855 | } else { | |||
1856 | reportUniqueWarning("unable to read the dynamic table from " + | |||
1857 | describe(*DynamicSec) + ": " + | |||
1858 | toString(RegOrErr.takeError())); | |||
1859 | } | |||
1860 | } | |||
1861 | ||||
1862 | // When we only have information from one of the SHT_DYNAMIC section header or | |||
1863 | // PT_DYNAMIC program header, just use that. | |||
1864 | if (!DynamicPhdr || !DynamicSec) { | |||
1865 | if ((DynamicPhdr && IsPhdrTableValid) || (DynamicSec && IsSecTableValid)) { | |||
1866 | DynamicTable = DynamicPhdr ? FromPhdr : FromSec; | |||
1867 | parseDynamicTable(); | |||
1868 | } else { | |||
1869 | reportUniqueWarning("no valid dynamic table was found"); | |||
1870 | } | |||
1871 | return; | |||
1872 | } | |||
1873 | ||||
1874 | // At this point we have tables found from the section header and from the | |||
1875 | // dynamic segment. Usually they match, but we have to do sanity checks to | |||
1876 | // verify that. | |||
1877 | ||||
1878 | if (FromPhdr.Addr != FromSec.Addr) | |||
1879 | reportUniqueWarning("SHT_DYNAMIC section header and PT_DYNAMIC " | |||
1880 | "program header disagree about " | |||
1881 | "the location of the dynamic table"); | |||
1882 | ||||
1883 | if (!IsPhdrTableValid && !IsSecTableValid) { | |||
1884 | reportUniqueWarning("no valid dynamic table was found"); | |||
1885 | return; | |||
1886 | } | |||
1887 | ||||
1888 | // Information in the PT_DYNAMIC program header has priority over the | |||
1889 | // information in a section header. | |||
1890 | if (IsPhdrTableValid) { | |||
1891 | if (!IsSecTableValid) | |||
1892 | reportUniqueWarning( | |||
1893 | "SHT_DYNAMIC dynamic table is invalid: PT_DYNAMIC will be used"); | |||
1894 | DynamicTable = FromPhdr; | |||
1895 | } else { | |||
1896 | reportUniqueWarning( | |||
1897 | "PT_DYNAMIC dynamic table is invalid: SHT_DYNAMIC will be used"); | |||
1898 | DynamicTable = FromSec; | |||
1899 | } | |||
1900 | ||||
1901 | parseDynamicTable(); | |||
1902 | } | |||
1903 | ||||
1904 | template <typename ELFT> | |||
1905 | ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> &O, | |||
1906 | ScopedPrinter &Writer) | |||
1907 | : ObjDumper(Writer, O.getFileName()), ObjF(O), Obj(O.getELFFile()), | |||
1908 | FileName(O.getFileName()), DynRelRegion(O, *this), | |||
1909 | DynRelaRegion(O, *this), DynRelrRegion(O, *this), | |||
1910 | DynPLTRelRegion(O, *this), DynSymTabShndxRegion(O, *this), | |||
1911 | DynamicTable(O, *this) { | |||
1912 | if (!O.IsContentValid()) | |||
1913 | return; | |||
1914 | ||||
1915 | typename ELFT::ShdrRange Sections = cantFail(Obj.sections()); | |||
1916 | for (const Elf_Shdr &Sec : Sections) { | |||
1917 | switch (Sec.sh_type) { | |||
1918 | case ELF::SHT_SYMTAB: | |||
1919 | if (!DotSymtabSec) | |||
1920 | DotSymtabSec = &Sec; | |||
1921 | break; | |||
1922 | case ELF::SHT_DYNSYM: | |||
1923 | if (!DotDynsymSec) | |||
1924 | DotDynsymSec = &Sec; | |||
1925 | ||||
1926 | if (!DynSymRegion) { | |||
1927 | Expected<DynRegionInfo> RegOrErr = | |||
1928 | createDRI(Sec.sh_offset, Sec.sh_size, Sec.sh_entsize); | |||
1929 | if (RegOrErr) { | |||
1930 | DynSymRegion = *RegOrErr; | |||
1931 | DynSymRegion->Context = describe(Sec); | |||
1932 | ||||
1933 | if (Expected<StringRef> E = Obj.getStringTableForSymtab(Sec)) | |||
1934 | DynamicStringTable = *E; | |||
1935 | else | |||
1936 | reportUniqueWarning("unable to get the string table for the " + | |||
1937 | describe(Sec) + ": " + toString(E.takeError())); | |||
1938 | } else { | |||
1939 | reportUniqueWarning("unable to read dynamic symbols from " + | |||
1940 | describe(Sec) + ": " + | |||
1941 | toString(RegOrErr.takeError())); | |||
1942 | } | |||
1943 | } | |||
1944 | break; | |||
1945 | case ELF::SHT_SYMTAB_SHNDX: { | |||
1946 | uint32_t SymtabNdx = Sec.sh_link; | |||
1947 | if (SymtabNdx >= Sections.size()) { | |||
1948 | reportUniqueWarning( | |||
1949 | "unable to get the associated symbol table for " + describe(Sec) + | |||
1950 | ": sh_link (" + Twine(SymtabNdx) + | |||
1951 | ") is greater than or equal to the total number of sections (" + | |||
1952 | Twine(Sections.size()) + ")"); | |||
1953 | continue; | |||
1954 | } | |||
1955 | ||||
1956 | if (Expected<ArrayRef<Elf_Word>> ShndxTableOrErr = | |||
1957 | Obj.getSHNDXTable(Sec)) { | |||
1958 | if (!ShndxTables.insert({&Sections[SymtabNdx], *ShndxTableOrErr}) | |||
1959 | .second) | |||
1960 | reportUniqueWarning( | |||
1961 | "multiple SHT_SYMTAB_SHNDX sections are linked to " + | |||
1962 | describe(Sec)); | |||
1963 | } else { | |||
1964 | reportUniqueWarning(ShndxTableOrErr.takeError()); | |||
1965 | } | |||
1966 | break; | |||
1967 | } | |||
1968 | case ELF::SHT_GNU_versym: | |||
1969 | if (!SymbolVersionSection) | |||
1970 | SymbolVersionSection = &Sec; | |||
1971 | break; | |||
1972 | case ELF::SHT_GNU_verdef: | |||
1973 | if (!SymbolVersionDefSection) | |||
1974 | SymbolVersionDefSection = &Sec; | |||
1975 | break; | |||
1976 | case ELF::SHT_GNU_verneed: | |||
1977 | if (!SymbolVersionNeedSection) | |||
1978 | SymbolVersionNeedSection = &Sec; | |||
1979 | break; | |||
1980 | case ELF::SHT_LLVM_ADDRSIG: | |||
1981 | if (!DotAddrsigSec) | |||
1982 | DotAddrsigSec = &Sec; | |||
1983 | break; | |||
1984 | } | |||
1985 | } | |||
1986 | ||||
1987 | loadDynamicTable(); | |||
1988 | } | |||
1989 | ||||
1990 | template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() { | |||
1991 | auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * { | |||
1992 | auto MappedAddrOrError = Obj.toMappedAddr(VAddr, [&](const Twine &Msg) { | |||
1993 | this->reportUniqueWarning(Msg); | |||
1994 | return Error::success(); | |||
1995 | }); | |||
1996 | if (!MappedAddrOrError) { | |||
1997 | this->reportUniqueWarning("unable to parse DT_" + | |||
1998 | Obj.getDynamicTagAsString(Tag) + ": " + | |||
1999 | llvm::toString(MappedAddrOrError.takeError())); | |||
2000 | return nullptr; | |||
2001 | } | |||
2002 | return MappedAddrOrError.get(); | |||
2003 | }; | |||
2004 | ||||
2005 | const char *StringTableBegin = nullptr; | |||
2006 | uint64_t StringTableSize = 0; | |||
2007 | std::optional<DynRegionInfo> DynSymFromTable; | |||
2008 | for (const Elf_Dyn &Dyn : dynamic_table()) { | |||
2009 | switch (Dyn.d_tag) { | |||
2010 | case ELF::DT_HASH: | |||
2011 | HashTable = reinterpret_cast<const Elf_Hash *>( | |||
2012 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
2013 | break; | |||
2014 | case ELF::DT_GNU_HASH: | |||
2015 | GnuHashTable = reinterpret_cast<const Elf_GnuHash *>( | |||
2016 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
2017 | break; | |||
2018 | case ELF::DT_STRTAB: | |||
2019 | StringTableBegin = reinterpret_cast<const char *>( | |||
2020 | toMappedAddr(Dyn.getTag(), Dyn.getPtr())); | |||
2021 | break; | |||
2022 | case ELF::DT_STRSZ: | |||
2023 | StringTableSize = Dyn.getVal(); | |||
2024 | break; | |||
2025 | case ELF::DT_SYMTAB: { | |||
2026 | // If we can't map the DT_SYMTAB value to an address (e.g. when there are | |||
2027 | // no program headers), we ignore its value. | |||
2028 | if (const uint8_t *VA = toMappedAddr(Dyn.getTag(), Dyn.getPtr())) { | |||
2029 | DynSymFromTable.emplace(ObjF, *this); | |||
2030 | DynSymFromTable->Addr = VA; | |||
2031 | DynSymFromTable->EntSize = sizeof(Elf_Sym); | |||
2032 | DynSymFromTable->EntSizePrintName = ""; | |||
2033 | } | |||
2034 | break; | |||
2035 | } | |||
2036 | case ELF::DT_SYMENT: { | |||
2037 | uint64_t Val = Dyn.getVal(); | |||
2038 | if (Val != sizeof(Elf_Sym)) | |||
2039 | this->reportUniqueWarning("DT_SYMENT value of 0x" + | |||
2040 | Twine::utohexstr(Val) + | |||
2041 | " is not the size of a symbol (0x" + | |||
2042 | Twine::utohexstr(sizeof(Elf_Sym)) + ")"); | |||
2043 | break; | |||
2044 | } | |||
2045 | case ELF::DT_RELA: | |||
2046 | DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2047 | break; | |||
2048 | case ELF::DT_RELASZ: | |||
2049 | DynRelaRegion.Size = Dyn.getVal(); | |||
2050 | DynRelaRegion.SizePrintName = "DT_RELASZ value"; | |||
2051 | break; | |||
2052 | case ELF::DT_RELAENT: | |||
2053 | DynRelaRegion.EntSize = Dyn.getVal(); | |||
2054 | DynRelaRegion.EntSizePrintName = "DT_RELAENT value"; | |||
2055 | break; | |||
2056 | case ELF::DT_SONAME: | |||
2057 | SONameOffset = Dyn.getVal(); | |||
2058 | break; | |||
2059 | case ELF::DT_REL: | |||
2060 | DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2061 | break; | |||
2062 | case ELF::DT_RELSZ: | |||
2063 | DynRelRegion.Size = Dyn.getVal(); | |||
2064 | DynRelRegion.SizePrintName = "DT_RELSZ value"; | |||
2065 | break; | |||
2066 | case ELF::DT_RELENT: | |||
2067 | DynRelRegion.EntSize = Dyn.getVal(); | |||
2068 | DynRelRegion.EntSizePrintName = "DT_RELENT value"; | |||
2069 | break; | |||
2070 | case ELF::DT_RELR: | |||
2071 | case ELF::DT_ANDROID_RELR: | |||
2072 | DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2073 | break; | |||
2074 | case ELF::DT_RELRSZ: | |||
2075 | case ELF::DT_ANDROID_RELRSZ: | |||
2076 | DynRelrRegion.Size = Dyn.getVal(); | |||
2077 | DynRelrRegion.SizePrintName = Dyn.d_tag == ELF::DT_RELRSZ | |||
2078 | ? "DT_RELRSZ value" | |||
2079 | : "DT_ANDROID_RELRSZ value"; | |||
2080 | break; | |||
2081 | case ELF::DT_RELRENT: | |||
2082 | case ELF::DT_ANDROID_RELRENT: | |||
2083 | DynRelrRegion.EntSize = Dyn.getVal(); | |||
2084 | DynRelrRegion.EntSizePrintName = Dyn.d_tag == ELF::DT_RELRENT | |||
2085 | ? "DT_RELRENT value" | |||
2086 | : "DT_ANDROID_RELRENT value"; | |||
2087 | break; | |||
2088 | case ELF::DT_PLTREL: | |||
2089 | if (Dyn.getVal() == DT_REL) | |||
2090 | DynPLTRelRegion.EntSize = sizeof(Elf_Rel); | |||
2091 | else if (Dyn.getVal() == DT_RELA) | |||
2092 | DynPLTRelRegion.EntSize = sizeof(Elf_Rela); | |||
2093 | else | |||
2094 | reportUniqueWarning(Twine("unknown DT_PLTREL value of ") + | |||
2095 | Twine((uint64_t)Dyn.getVal())); | |||
2096 | DynPLTRelRegion.EntSizePrintName = "PLTREL entry size"; | |||
2097 | break; | |||
2098 | case ELF::DT_JMPREL: | |||
2099 | DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2100 | break; | |||
2101 | case ELF::DT_PLTRELSZ: | |||
2102 | DynPLTRelRegion.Size = Dyn.getVal(); | |||
2103 | DynPLTRelRegion.SizePrintName = "DT_PLTRELSZ value"; | |||
2104 | break; | |||
2105 | case ELF::DT_SYMTAB_SHNDX: | |||
2106 | DynSymTabShndxRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); | |||
2107 | DynSymTabShndxRegion.EntSize = sizeof(Elf_Word); | |||
2108 | break; | |||
2109 | } | |||
2110 | } | |||
2111 | ||||
2112 | if (StringTableBegin) { | |||
2113 | const uint64_t FileSize = Obj.getBufSize(); | |||
2114 | const uint64_t Offset = (const uint8_t *)StringTableBegin - Obj.base(); | |||
2115 | if (StringTableSize > FileSize - Offset) | |||
2116 | reportUniqueWarning( | |||
2117 | "the dynamic string table at 0x" + Twine::utohexstr(Offset) + | |||
2118 | " goes past the end of the file (0x" + Twine::utohexstr(FileSize) + | |||
2119 | ") with DT_STRSZ = 0x" + Twine::utohexstr(StringTableSize)); | |||
2120 | else | |||
2121 | DynamicStringTable = StringRef(StringTableBegin, StringTableSize); | |||
2122 | } | |||
2123 | ||||
2124 | const bool IsHashTableSupported = getHashTableEntSize() == 4; | |||
2125 | if (DynSymRegion) { | |||
2126 | // Often we find the information about the dynamic symbol table | |||
2127 | // location in the SHT_DYNSYM section header. However, the value in | |||
2128 | // DT_SYMTAB has priority, because it is used by dynamic loaders to | |||
2129 | // locate .dynsym at runtime. The location we find in the section header | |||
2130 | // and the location we find here should match. | |||
2131 | if (DynSymFromTable && DynSymFromTable->Addr != DynSymRegion->Addr) | |||
2132 | reportUniqueWarning( | |||
2133 | createError("SHT_DYNSYM section header and DT_SYMTAB disagree about " | |||
2134 | "the location of the dynamic symbol table")); | |||
2135 | ||||
2136 | // According to the ELF gABI: "The number of symbol table entries should | |||
2137 | // equal nchain". Check to see if the DT_HASH hash table nchain value | |||
2138 | // conflicts with the number of symbols in the dynamic symbol table | |||
2139 | // according to the section header. | |||
2140 | if (HashTable && IsHashTableSupported) { | |||
2141 | if (DynSymRegion->EntSize == 0) | |||
2142 | reportUniqueWarning("SHT_DYNSYM section has sh_entsize == 0"); | |||
2143 | else if (HashTable->nchain != DynSymRegion->Size / DynSymRegion->EntSize) | |||
2144 | reportUniqueWarning( | |||
2145 | "hash table nchain (" + Twine(HashTable->nchain) + | |||
2146 | ") differs from symbol count derived from SHT_DYNSYM section " | |||
2147 | "header (" + | |||
2148 | Twine(DynSymRegion->Size / DynSymRegion->EntSize) + ")"); | |||
2149 | } | |||
2150 | } | |||
2151 | ||||
2152 | // Delay the creation of the actual dynamic symbol table until now, so that | |||
2153 | // checks can always be made against the section header-based properties, | |||
2154 | // without worrying about tag order. | |||
2155 | if (DynSymFromTable) { | |||
2156 | if (!DynSymRegion) { | |||
2157 | DynSymRegion = DynSymFromTable; | |||
2158 | } else { | |||
2159 | DynSymRegion->Addr = DynSymFromTable->Addr; | |||
2160 | DynSymRegion->EntSize = DynSymFromTable->EntSize; | |||
2161 | DynSymRegion->EntSizePrintName = DynSymFromTable->EntSizePrintName; | |||
2162 | } | |||
2163 | } | |||
2164 | ||||
2165 | // Derive the dynamic symbol table size from the DT_HASH hash table, if | |||
2166 | // present. | |||
2167 | if (HashTable && IsHashTableSupported && DynSymRegion) { | |||
2168 | const uint64_t FileSize = Obj.getBufSize(); | |||
2169 | const uint64_t DerivedSize = | |||
2170 | (uint64_t)HashTable->nchain * DynSymRegion->EntSize; | |||
2171 | const uint64_t Offset = (const uint8_t *)DynSymRegion->Addr - Obj.base(); | |||
2172 | if (DerivedSize > FileSize - Offset) | |||
2173 | reportUniqueWarning( | |||
2174 | "the size (0x" + Twine::utohexstr(DerivedSize) + | |||
2175 | ") of the dynamic symbol table at 0x" + Twine::utohexstr(Offset) + | |||
2176 | ", derived from the hash table, goes past the end of the file (0x" + | |||
2177 | Twine::utohexstr(FileSize) + ") and will be ignored"); | |||
2178 | else | |||
2179 | DynSymRegion->Size = HashTable->nchain * DynSymRegion->EntSize; | |||
2180 | } | |||
2181 | } | |||
2182 | ||||
2183 | template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { | |||
2184 | // Dump version symbol section. | |||
2185 | printVersionSymbolSection(SymbolVersionSection); | |||
2186 | ||||
2187 | // Dump version definition section. | |||
2188 | printVersionDefinitionSection(SymbolVersionDefSection); | |||
2189 | ||||
2190 | // Dump version dependency section. | |||
2191 | printVersionDependencySection(SymbolVersionNeedSection); | |||
2192 | } | |||
2193 | ||||
2194 | #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ | |||
2195 | { #enum, prefix##_##enum } | |||
2196 | ||||
2197 | const EnumEntry<unsigned> ElfDynamicDTFlags[] = { | |||
2198 | LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), | |||
2199 | LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), | |||
2200 | LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), | |||
2201 | LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), | |||
2202 | LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) | |||
2203 | }; | |||
2204 | ||||
2205 | const EnumEntry<unsigned> ElfDynamicDTFlags1[] = { | |||
2206 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), | |||
2207 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), | |||
2208 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), | |||
2209 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), | |||
2210 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), | |||
2211 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), | |||
2212 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), | |||
2213 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), | |||
2214 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), | |||
2215 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), | |||
2216 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), | |||
2217 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), | |||
2218 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), | |||
2219 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), | |||
2220 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), | |||
2221 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), | |||
2222 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND), | |||
2223 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), | |||
2224 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), | |||
2225 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), | |||
2226 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), | |||
2227 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), | |||
2228 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), | |||
2229 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), | |||
2230 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), | |||
2231 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON), | |||
2232 | LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE), | |||
2233 | }; | |||
2234 | ||||
2235 | const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = { | |||
2236 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), | |||
2237 | LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), | |||
2238 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), | |||
2239 | LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), | |||
2240 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), | |||
2241 | LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), | |||
2242 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), | |||
2243 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), | |||
2244 | LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), | |||
2245 | LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), | |||
2246 | LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), | |||
2247 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), | |||
2248 | LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), | |||
2249 | LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), | |||
2250 | LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), | |||
2251 | LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) | |||
2252 | }; | |||
2253 | ||||
2254 | #undef LLVM_READOBJ_DT_FLAG_ENT | |||
2255 | ||||
2256 | template <typename T, typename TFlag> | |||
2257 | void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) { | |||
2258 | SmallVector<EnumEntry<TFlag>, 10> SetFlags; | |||
2259 | for (const EnumEntry<TFlag> &Flag : Flags) | |||
2260 | if (Flag.Value != 0 && (Value & Flag.Value) == Flag.Value) | |||
2261 | SetFlags.push_back(Flag); | |||
2262 | ||||
2263 | for (const EnumEntry<TFlag> &Flag : SetFlags) | |||
2264 | OS << Flag.Name << " "; | |||
2265 | } | |||
2266 | ||||
2267 | template <class ELFT> | |||
2268 | const typename ELFT::Shdr * | |||
2269 | ELFDumper<ELFT>::findSectionByName(StringRef Name) const { | |||
2270 | for (const Elf_Shdr &Shdr : cantFail(Obj.sections())) { | |||
2271 | if (Expected<StringRef> NameOrErr = Obj.getSectionName(Shdr)) { | |||
2272 | if (*NameOrErr == Name) | |||
2273 | return &Shdr; | |||
2274 | } else { | |||
2275 | reportUniqueWarning("unable to read the name of " + describe(Shdr) + | |||
2276 | ": " + toString(NameOrErr.takeError())); | |||
2277 | } | |||
2278 | } | |||
2279 | return nullptr; | |||
2280 | } | |||
2281 | ||||
2282 | template <class ELFT> | |||
2283 | std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type, | |||
2284 | uint64_t Value) const { | |||
2285 | auto FormatHexValue = [](uint64_t V) { | |||
2286 | std::string Str; | |||
2287 | raw_string_ostream OS(Str); | |||
2288 | const char *ConvChar = | |||
2289 | (opts::Output == opts::GNU) ? "0x%" PRIx64"l" "x" : "0x%" PRIX64"l" "X"; | |||
2290 | OS << format(ConvChar, V); | |||
2291 | return OS.str(); | |||
2292 | }; | |||
2293 | ||||
2294 | auto FormatFlags = [](uint64_t V, | |||
2295 | llvm::ArrayRef<llvm::EnumEntry<unsigned int>> Array) { | |||
2296 | std::string Str; | |||
2297 | raw_string_ostream OS(Str); | |||
2298 | printFlags(V, Array, OS); | |||
2299 | return OS.str(); | |||
2300 | }; | |||
2301 | ||||
2302 | // Handle custom printing of architecture specific tags | |||
2303 | switch (Obj.getHeader().e_machine) { | |||
2304 | case EM_AARCH64: | |||
2305 | switch (Type) { | |||
2306 | case DT_AARCH64_BTI_PLT: | |||
2307 | case DT_AARCH64_PAC_PLT: | |||
2308 | case DT_AARCH64_VARIANT_PCS: | |||
2309 | case DT_AARCH64_MEMTAG_GLOBALSSZ: | |||
2310 | return std::to_string(Value); | |||
2311 | case DT_AARCH64_MEMTAG_MODE: | |||
2312 | switch (Value) { | |||
2313 | case 0: | |||
2314 | return "Synchronous (0)"; | |||
2315 | case 1: | |||
2316 | return "Asynchronous (1)"; | |||
2317 | default: | |||
2318 | return (Twine("Unknown (") + Twine(Value) + ")").str(); | |||
2319 | } | |||
2320 | case DT_AARCH64_MEMTAG_HEAP: | |||
2321 | case DT_AARCH64_MEMTAG_STACK: | |||
2322 | switch (Value) { | |||
2323 | case 0: | |||
2324 | return "Disabled (0)"; | |||
2325 | case 1: | |||
2326 | return "Enabled (1)"; | |||
2327 | default: | |||
2328 | return (Twine("Unknown (") + Twine(Value) + ")").str(); | |||
2329 | } | |||
2330 | case DT_AARCH64_MEMTAG_GLOBALS: | |||
2331 | return (Twine("0x") + utohexstr(Value, /*LowerCase=*/true)).str(); | |||
2332 | default: | |||
2333 | break; | |||
2334 | } | |||
2335 | break; | |||
2336 | case EM_HEXAGON: | |||
2337 | switch (Type) { | |||
2338 | case DT_HEXAGON_VER: | |||
2339 | return std::to_string(Value); | |||
2340 | case DT_HEXAGON_SYMSZ: | |||
2341 | case DT_HEXAGON_PLT: | |||
2342 | return FormatHexValue(Value); | |||
2343 | default: | |||
2344 | break; | |||
2345 | } | |||
2346 | break; | |||
2347 | case EM_MIPS: | |||
2348 | switch (Type) { | |||
2349 | case DT_MIPS_RLD_VERSION: | |||
2350 | case DT_MIPS_LOCAL_GOTNO: | |||
2351 | case DT_MIPS_SYMTABNO: | |||
2352 | case DT_MIPS_UNREFEXTNO: | |||
2353 | return std::to_string(Value); | |||
2354 | case DT_MIPS_TIME_STAMP: | |||
2355 | case DT_MIPS_ICHECKSUM: | |||
2356 | case DT_MIPS_IVERSION: | |||
2357 | case DT_MIPS_BASE_ADDRESS: | |||
2358 | case DT_MIPS_MSYM: | |||
2359 | case DT_MIPS_CONFLICT: | |||
2360 | case DT_MIPS_LIBLIST: | |||
2361 | case DT_MIPS_CONFLICTNO: | |||
2362 | case DT_MIPS_LIBLISTNO: | |||
2363 | case DT_MIPS_GOTSYM: | |||
2364 | case DT_MIPS_HIPAGENO: | |||
2365 | case DT_MIPS_RLD_MAP: | |||
2366 | case DT_MIPS_DELTA_CLASS: | |||
2367 | case DT_MIPS_DELTA_CLASS_NO: | |||
2368 | case DT_MIPS_DELTA_INSTANCE: | |||
2369 | case DT_MIPS_DELTA_RELOC: | |||
2370 | case DT_MIPS_DELTA_RELOC_NO: | |||
2371 | case DT_MIPS_DELTA_SYM: | |||
2372 | case DT_MIPS_DELTA_SYM_NO: | |||
2373 | case DT_MIPS_DELTA_CLASSSYM: | |||
2374 | case DT_MIPS_DELTA_CLASSSYM_NO: | |||
2375 | case DT_MIPS_CXX_FLAGS: | |||
2376 | case DT_MIPS_PIXIE_INIT: | |||
2377 | case DT_MIPS_SYMBOL_LIB: | |||
2378 | case DT_MIPS_LOCALPAGE_GOTIDX: | |||
2379 | case DT_MIPS_LOCAL_GOTIDX: | |||
2380 | case DT_MIPS_HIDDEN_GOTIDX: | |||
2381 | case DT_MIPS_PROTECTED_GOTIDX: | |||
2382 | case DT_MIPS_OPTIONS: | |||
2383 | case DT_MIPS_INTERFACE: | |||
2384 | case DT_MIPS_DYNSTR_ALIGN: | |||
2385 | case DT_MIPS_INTERFACE_SIZE: | |||
2386 | case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: | |||
2387 | case DT_MIPS_PERF_SUFFIX: | |||
2388 | case DT_MIPS_COMPACT_SIZE: | |||
2389 | case DT_MIPS_GP_VALUE: | |||
2390 | case DT_MIPS_AUX_DYNAMIC: | |||
2391 | case DT_MIPS_PLTGOT: | |||
2392 | case DT_MIPS_RWPLT: | |||
2393 | case DT_MIPS_RLD_MAP_REL: | |||
2394 | case DT_MIPS_XHASH: | |||
2395 | return FormatHexValue(Value); | |||
2396 | case DT_MIPS_FLAGS: | |||
2397 | return FormatFlags(Value, ArrayRef(ElfDynamicDTMipsFlags)); | |||
2398 | default: | |||
2399 | break; | |||
2400 | } | |||
2401 | break; | |||
2402 | default: | |||
2403 | break; | |||
2404 | } | |||
2405 | ||||
2406 | switch (Type) { | |||
2407 | case DT_PLTREL: | |||
2408 | if (Value == DT_REL) | |||
2409 | return "REL"; | |||
2410 | if (Value == DT_RELA) | |||
2411 | return "RELA"; | |||
2412 | [[fallthrough]]; | |||
2413 | case DT_PLTGOT: | |||
2414 | case DT_HASH: | |||
2415 | case DT_STRTAB: | |||
2416 | case DT_SYMTAB: | |||
2417 | case DT_RELA: | |||
2418 | case DT_INIT: | |||
2419 | case DT_FINI: | |||
2420 | case DT_REL: | |||
2421 | case DT_JMPREL: | |||
2422 | case DT_INIT_ARRAY: | |||
2423 | case DT_FINI_ARRAY: | |||
2424 | case DT_PREINIT_ARRAY: | |||
2425 | case DT_DEBUG: | |||
2426 | case DT_VERDEF: | |||
2427 | case DT_VERNEED: | |||
2428 | case DT_VERSYM: | |||
2429 | case DT_GNU_HASH: | |||
2430 | case DT_NULL: | |||
2431 | return FormatHexValue(Value); | |||
2432 | case DT_RELACOUNT: | |||
2433 | case DT_RELCOUNT: | |||
2434 | case DT_VERDEFNUM: | |||
2435 | case DT_VERNEEDNUM: | |||
2436 | return std::to_string(Value); | |||
2437 | case DT_PLTRELSZ: | |||
2438 | case DT_RELASZ: | |||
2439 | case DT_RELAENT: | |||
2440 | case DT_STRSZ: | |||
2441 | case DT_SYMENT: | |||
2442 | case DT_RELSZ: | |||
2443 | case DT_RELENT: | |||
2444 | case DT_INIT_ARRAYSZ: | |||
2445 | case DT_FINI_ARRAYSZ: | |||
2446 | case DT_PREINIT_ARRAYSZ: | |||
2447 | case DT_RELRSZ: | |||
2448 | case DT_RELRENT: | |||
2449 | case DT_ANDROID_RELSZ: | |||
2450 | case DT_ANDROID_RELASZ: | |||
2451 | return std::to_string(Value) + " (bytes)"; | |||
2452 | case DT_NEEDED: | |||
2453 | case DT_SONAME: | |||
2454 | case DT_AUXILIARY: | |||
2455 | case DT_USED: | |||
2456 | case DT_FILTER: | |||
2457 | case DT_RPATH: | |||
2458 | case DT_RUNPATH: { | |||
2459 | const std::map<uint64_t, const char *> TagNames = { | |||
2460 | {DT_NEEDED, "Shared library"}, {DT_SONAME, "Library soname"}, | |||
2461 | {DT_AUXILIARY, "Auxiliary library"}, {DT_USED, "Not needed object"}, | |||
2462 | {DT_FILTER, "Filter library"}, {DT_RPATH, "Library rpath"}, | |||
2463 | {DT_RUNPATH, "Library runpath"}, | |||
2464 | }; | |||
2465 | ||||
2466 | return (Twine(TagNames.at(Type)) + ": [" + getDynamicString(Value) + "]") | |||
2467 | .str(); | |||
2468 | } | |||
2469 | case DT_FLAGS: | |||
2470 | return FormatFlags(Value, ArrayRef(ElfDynamicDTFlags)); | |||
2471 | case DT_FLAGS_1: | |||
2472 | return FormatFlags(Value, ArrayRef(ElfDynamicDTFlags1)); | |||
2473 | default: | |||
2474 | return FormatHexValue(Value); | |||
2475 | } | |||
2476 | } | |||
2477 | ||||
2478 | template <class ELFT> | |||
2479 | StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { | |||
2480 | if (DynamicStringTable.empty() && !DynamicStringTable.data()) { | |||
2481 | reportUniqueWarning("string table was not found"); | |||
2482 | return "<?>"; | |||
2483 | } | |||
2484 | ||||
2485 | auto WarnAndReturn = [this](const Twine &Msg, uint64_t Offset) { | |||
2486 | reportUniqueWarning("string table at offset 0x" + Twine::utohexstr(Offset) + | |||
2487 | Msg); | |||
2488 | return "<?>"; | |||
2489 | }; | |||
2490 | ||||
2491 | const uint64_t FileSize = Obj.getBufSize(); | |||
2492 | const uint64_t Offset = | |||
2493 | (const uint8_t *)DynamicStringTable.data() - Obj.base(); | |||
2494 | if (DynamicStringTable.size() > FileSize - Offset) | |||
2495 | return WarnAndReturn(" with size 0x" + | |||
2496 | Twine::utohexstr(DynamicStringTable.size()) + | |||
2497 | " goes past the end of the file (0x" + | |||
2498 | Twine::utohexstr(FileSize) + ")", | |||
2499 | Offset); | |||
2500 | ||||
2501 | if (Value >= DynamicStringTable.size()) | |||
2502 | return WarnAndReturn( | |||
2503 | ": unable to read the string at 0x" + Twine::utohexstr(Offset + Value) + | |||
2504 | ": it goes past the end of the table (0x" + | |||
2505 | Twine::utohexstr(Offset + DynamicStringTable.size()) + ")", | |||
2506 | Offset); | |||
2507 | ||||
2508 | if (DynamicStringTable.back() != '\0') | |||
2509 | return WarnAndReturn(": unable to read the string at 0x" + | |||
2510 | Twine::utohexstr(Offset + Value) + | |||
2511 | ": the string table is not null-terminated", | |||
2512 | Offset); | |||
2513 | ||||
2514 | return DynamicStringTable.data() + Value; | |||
2515 | } | |||
2516 | ||||
2517 | template <class ELFT> void ELFDumper<ELFT>::printUnwindInfo() { | |||
2518 | DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF); | |||
2519 | Ctx.printUnwindInformation(); | |||
2520 | } | |||
2521 | ||||
2522 | // The namespace is needed to fix the compilation with GCC older than 7.0+. | |||
2523 | namespace { | |||
2524 | template <> void ELFDumper<ELF32LE>::printUnwindInfo() { | |||
2525 | if (Obj.getHeader().e_machine == EM_ARM) { | |||
2526 | ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF.getFileName(), | |||
2527 | DotSymtabSec); | |||
2528 | Ctx.PrintUnwindInformation(); | |||
2529 | } | |||
2530 | DwarfCFIEH::PrinterContext<ELF32LE> Ctx(W, ObjF); | |||
2531 | Ctx.printUnwindInformation(); | |||
2532 | } | |||
2533 | } // namespace | |||
2534 | ||||
2535 | template <class ELFT> void ELFDumper<ELFT>::printNeededLibraries() { | |||
2536 | ListScope D(W, "NeededLibraries"); | |||
2537 | ||||
2538 | std::vector<StringRef> Libs; | |||
2539 | for (const auto &Entry : dynamic_table()) | |||
2540 | if (Entry.d_tag == ELF::DT_NEEDED) | |||
2541 | Libs.push_back(getDynamicString(Entry.d_un.d_val)); | |||
2542 | ||||
2543 | llvm::sort(Libs); | |||
2544 | ||||
2545 | for (StringRef L : Libs) | |||
2546 | W.startLine() << L << "\n"; | |||
2547 | } | |||
2548 | ||||
2549 | template <class ELFT> | |||
2550 | static Error checkHashTable(const ELFDumper<ELFT> &Dumper, | |||
2551 | const typename ELFT::Hash *H, | |||
2552 | bool *IsHeaderValid = nullptr) { | |||
2553 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
2554 | const uint64_t SecOffset = (const uint8_t *)H - Obj.base(); | |||
2555 | if (Dumper.getHashTableEntSize() == 8) { | |||
2556 | auto It = llvm::find_if(ElfMachineType, [&](const EnumEntry<unsigned> &E) { | |||
2557 | return E.Value == Obj.getHeader().e_machine; | |||
2558 | }); | |||
2559 | if (IsHeaderValid) | |||
2560 | *IsHeaderValid = false; | |||
2561 | return createError("the hash table at 0x" + Twine::utohexstr(SecOffset) + | |||
2562 | " is not supported: it contains non-standard 8 " | |||
2563 | "byte entries on " + | |||
2564 | It->AltName + " platform"); | |||
2565 | } | |||
2566 | ||||
2567 | auto MakeError = [&](const Twine &Msg = "") { | |||
2568 | return createError("the hash table at offset 0x" + | |||
2569 | Twine::utohexstr(SecOffset) + | |||
2570 | " goes past the end of the file (0x" + | |||
2571 | Twine::utohexstr(Obj.getBufSize()) + ")" + Msg); | |||
2572 | }; | |||
2573 | ||||
2574 | // Each SHT_HASH section starts from two 32-bit fields: nbucket and nchain. | |||
2575 | const unsigned HeaderSize = 2 * sizeof(typename ELFT::Word); | |||
2576 | ||||
2577 | if (IsHeaderValid) | |||
2578 | *IsHeaderValid = Obj.getBufSize() - SecOffset >= HeaderSize; | |||
2579 | ||||
2580 | if (Obj.getBufSize() - SecOffset < HeaderSize) | |||
2581 | return MakeError(); | |||
2582 | ||||
2583 | if (Obj.getBufSize() - SecOffset - HeaderSize < | |||
2584 | ((uint64_t)H->nbucket + H->nchain) * sizeof(typename ELFT::Word)) | |||
2585 | return MakeError(", nbucket = " + Twine(H->nbucket) + | |||
2586 | ", nchain = " + Twine(H->nchain)); | |||
2587 | return Error::success(); | |||
2588 | } | |||
2589 | ||||
2590 | template <class ELFT> | |||
2591 | static Error checkGNUHashTable(const ELFFile<ELFT> &Obj, | |||
2592 | const typename ELFT::GnuHash *GnuHashTable, | |||
2593 | bool *IsHeaderValid = nullptr) { | |||
2594 | const uint8_t *TableData = reinterpret_cast<const uint8_t *>(GnuHashTable); | |||
2595 | 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", 2596, __extension__ __PRETTY_FUNCTION__)) | |||
2596 | "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", 2596, __extension__ __PRETTY_FUNCTION__)); | |||
2597 | ||||
2598 | uint64_t TableOffset = TableData - Obj.base(); | |||
2599 | if (IsHeaderValid) | |||
2600 | *IsHeaderValid = TableOffset + /*Header size:*/ 16 < Obj.getBufSize(); | |||
2601 | if (TableOffset + 16 + (uint64_t)GnuHashTable->nbuckets * 4 + | |||
2602 | (uint64_t)GnuHashTable->maskwords * sizeof(typename ELFT::Off) >= | |||
2603 | Obj.getBufSize()) | |||
2604 | return createError("unable to dump the SHT_GNU_HASH " | |||
2605 | "section at 0x" + | |||
2606 | Twine::utohexstr(TableOffset) + | |||
2607 | ": it goes past the end of the file"); | |||
2608 | return Error::success(); | |||
2609 | } | |||
2610 | ||||
2611 | template <typename ELFT> void ELFDumper<ELFT>::printHashTable() { | |||
2612 | DictScope D(W, "HashTable"); | |||
2613 | if (!HashTable) | |||
2614 | return; | |||
2615 | ||||
2616 | bool IsHeaderValid; | |||
2617 | Error Err = checkHashTable(*this, HashTable, &IsHeaderValid); | |||
2618 | if (IsHeaderValid) { | |||
2619 | W.printNumber("Num Buckets", HashTable->nbucket); | |||
2620 | W.printNumber("Num Chains", HashTable->nchain); | |||
2621 | } | |||
2622 | ||||
2623 | if (Err) { | |||
2624 | reportUniqueWarning(std::move(Err)); | |||
2625 | return; | |||
2626 | } | |||
2627 | ||||
2628 | W.printList("Buckets", HashTable->buckets()); | |||
2629 | W.printList("Chains", HashTable->chains()); | |||
2630 | } | |||
2631 | ||||
2632 | template <class ELFT> | |||
2633 | static Expected<ArrayRef<typename ELFT::Word>> | |||
2634 | getGnuHashTableChains(std::optional<DynRegionInfo> DynSymRegion, | |||
2635 | const typename ELFT::GnuHash *GnuHashTable) { | |||
2636 | if (!DynSymRegion) | |||
2637 | return createError("no dynamic symbol table found"); | |||
2638 | ||||
2639 | ArrayRef<typename ELFT::Sym> DynSymTable = | |||
2640 | DynSymRegion->template getAsArrayRef<typename ELFT::Sym>(); | |||
2641 | size_t NumSyms = DynSymTable.size(); | |||
2642 | if (!NumSyms) | |||
2643 | return createError("the dynamic symbol table is empty"); | |||
2644 | ||||
2645 | if (GnuHashTable->symndx < NumSyms) | |||
2646 | return GnuHashTable->values(NumSyms); | |||
2647 | ||||
2648 | // A normal empty GNU hash table section produced by linker might have | |||
2649 | // symndx set to the number of dynamic symbols + 1 (for the zero symbol) | |||
2650 | // and have dummy null values in the Bloom filter and in the buckets | |||
2651 | // vector (or no values at all). It happens because the value of symndx is not | |||
2652 | // important for dynamic loaders when the GNU hash table is empty. They just | |||
2653 | // skip the whole object during symbol lookup. In such cases, the symndx value | |||
2654 | // is irrelevant and we should not report a warning. | |||
2655 | ArrayRef<typename ELFT::Word> Buckets = GnuHashTable->buckets(); | |||
2656 | if (!llvm::all_of(Buckets, [](typename ELFT::Word V) { return V == 0; })) | |||
2657 | return createError( | |||
2658 | "the first hashed symbol index (" + Twine(GnuHashTable->symndx) + | |||
2659 | ") is greater than or equal to the number of dynamic symbols (" + | |||
2660 | Twine(NumSyms) + ")"); | |||
2661 | // There is no way to represent an array of (dynamic symbols count - symndx) | |||
2662 | // length. | |||
2663 | return ArrayRef<typename ELFT::Word>(); | |||
2664 | } | |||
2665 | ||||
2666 | template <typename ELFT> | |||
2667 | void ELFDumper<ELFT>::printGnuHashTable() { | |||
2668 | DictScope D(W, "GnuHashTable"); | |||
2669 | if (!GnuHashTable) | |||
2670 | return; | |||
2671 | ||||
2672 | bool IsHeaderValid; | |||
2673 | Error Err = checkGNUHashTable<ELFT>(Obj, GnuHashTable, &IsHeaderValid); | |||
2674 | if (IsHeaderValid) { | |||
2675 | W.printNumber("Num Buckets", GnuHashTable->nbuckets); | |||
2676 | W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); | |||
2677 | W.printNumber("Num Mask Words", GnuHashTable->maskwords); | |||
2678 | W.printNumber("Shift Count", GnuHashTable->shift2); | |||
2679 | } | |||
2680 | ||||
2681 | if (Err) { | |||
2682 | reportUniqueWarning(std::move(Err)); | |||
2683 | return; | |||
2684 | } | |||
2685 | ||||
2686 | ArrayRef<typename ELFT::Off> BloomFilter = GnuHashTable->filter(); | |||
2687 | W.printHexList("Bloom Filter", BloomFilter); | |||
2688 | ||||
2689 | ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets(); | |||
2690 | W.printList("Buckets", Buckets); | |||
2691 | ||||
2692 | Expected<ArrayRef<Elf_Word>> Chains = | |||
2693 | getGnuHashTableChains<ELFT>(DynSymRegion, GnuHashTable); | |||
2694 | if (!Chains) { | |||
2695 | reportUniqueWarning("unable to dump 'Values' for the SHT_GNU_HASH " | |||
2696 | "section: " + | |||
2697 | toString(Chains.takeError())); | |||
2698 | return; | |||
2699 | } | |||
2700 | ||||
2701 | W.printHexList("Values", *Chains); | |||
2702 | } | |||
2703 | ||||
2704 | template <typename ELFT> void ELFDumper<ELFT>::printHashHistograms() { | |||
2705 | // Print histogram for the .hash section. | |||
2706 | if (this->HashTable) { | |||
2707 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
2708 | this->reportUniqueWarning(std::move(E)); | |||
2709 | else | |||
2710 | printHashHistogram(*this->HashTable); | |||
2711 | } | |||
2712 | ||||
2713 | // Print histogram for the .gnu.hash section. | |||
2714 | if (this->GnuHashTable) { | |||
2715 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
2716 | this->reportUniqueWarning(std::move(E)); | |||
2717 | else | |||
2718 | printGnuHashHistogram(*this->GnuHashTable); | |||
2719 | } | |||
2720 | } | |||
2721 | ||||
2722 | template <typename ELFT> | |||
2723 | void ELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) const { | |||
2724 | size_t NBucket = HashTable.nbucket; | |||
2725 | size_t NChain = HashTable.nchain; | |||
2726 | ArrayRef<Elf_Word> Buckets = HashTable.buckets(); | |||
2727 | ArrayRef<Elf_Word> Chains = HashTable.chains(); | |||
2728 | size_t TotalSyms = 0; | |||
2729 | // If hash table is correct, we have at least chains with 0 length. | |||
2730 | size_t MaxChain = 1; | |||
2731 | ||||
2732 | if (NChain == 0 || NBucket == 0) | |||
2733 | return; | |||
2734 | ||||
2735 | std::vector<size_t> ChainLen(NBucket, 0); | |||
2736 | // Go over all buckets and and note chain lengths of each bucket (total | |||
2737 | // unique chain lengths). | |||
2738 | for (size_t B = 0; B < NBucket; ++B) { | |||
2739 | BitVector Visited(NChain); | |||
2740 | for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) { | |||
2741 | if (C == ELF::STN_UNDEF) | |||
2742 | break; | |||
2743 | if (Visited[C]) { | |||
2744 | this->reportUniqueWarning( | |||
2745 | ".hash section is invalid: bucket " + Twine(C) + | |||
2746 | ": a cycle was detected in the linked chain"); | |||
2747 | break; | |||
2748 | } | |||
2749 | Visited[C] = true; | |||
2750 | if (MaxChain <= ++ChainLen[B]) | |||
2751 | ++MaxChain; | |||
2752 | } | |||
2753 | TotalSyms += ChainLen[B]; | |||
2754 | } | |||
2755 | ||||
2756 | if (!TotalSyms) | |||
2757 | return; | |||
2758 | ||||
2759 | std::vector<size_t> Count(MaxChain, 0); | |||
2760 | // Count how long is the chain for each bucket. | |||
2761 | for (size_t B = 0; B < NBucket; B++) | |||
2762 | ++Count[ChainLen[B]]; | |||
2763 | // Print Number of buckets with each chain lengths and their cumulative | |||
2764 | // coverage of the symbols. | |||
2765 | printHashHistogramStats(NBucket, MaxChain, TotalSyms, Count, /*IsGnu=*/false); | |||
2766 | } | |||
2767 | ||||
2768 | template <class ELFT> | |||
2769 | void ELFDumper<ELFT>::printGnuHashHistogram( | |||
2770 | const Elf_GnuHash &GnuHashTable) const { | |||
2771 | Expected<ArrayRef<Elf_Word>> ChainsOrErr = | |||
2772 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHashTable); | |||
2773 | if (!ChainsOrErr) { | |||
2774 | this->reportUniqueWarning("unable to print the GNU hash table histogram: " + | |||
2775 | toString(ChainsOrErr.takeError())); | |||
2776 | return; | |||
2777 | } | |||
2778 | ||||
2779 | ArrayRef<Elf_Word> Chains = *ChainsOrErr; | |||
2780 | size_t Symndx = GnuHashTable.symndx; | |||
2781 | size_t TotalSyms = 0; | |||
2782 | size_t MaxChain = 1; | |||
2783 | ||||
2784 | size_t NBucket = GnuHashTable.nbuckets; | |||
2785 | if (Chains.empty() || NBucket == 0) | |||
2786 | return; | |||
2787 | ||||
2788 | ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets(); | |||
2789 | std::vector<size_t> ChainLen(NBucket, 0); | |||
2790 | for (size_t B = 0; B < NBucket; ++B) { | |||
2791 | if (!Buckets[B]) | |||
2792 | continue; | |||
2793 | size_t Len = 1; | |||
2794 | for (size_t C = Buckets[B] - Symndx; | |||
2795 | C < Chains.size() && (Chains[C] & 1) == 0; ++C) | |||
2796 | if (MaxChain < ++Len) | |||
2797 | ++MaxChain; | |||
2798 | ChainLen[B] = Len; | |||
2799 | TotalSyms += Len; | |||
2800 | } | |||
2801 | ++MaxChain; | |||
2802 | ||||
2803 | if (!TotalSyms) | |||
2804 | return; | |||
2805 | ||||
2806 | std::vector<size_t> Count(MaxChain, 0); | |||
2807 | for (size_t B = 0; B < NBucket; ++B) | |||
2808 | ++Count[ChainLen[B]]; | |||
2809 | // Print Number of buckets with each chain lengths and their cumulative | |||
2810 | // coverage of the symbols. | |||
2811 | printHashHistogramStats(NBucket, MaxChain, TotalSyms, Count, /*IsGnu=*/true); | |||
2812 | } | |||
2813 | ||||
2814 | template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { | |||
2815 | StringRef SOName = "<Not found>"; | |||
2816 | if (SONameOffset) | |||
2817 | SOName = getDynamicString(*SONameOffset); | |||
2818 | W.printString("LoadName", SOName); | |||
2819 | } | |||
2820 | ||||
2821 | template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() { | |||
2822 | switch (Obj.getHeader().e_machine) { | |||
2823 | case EM_ARM: | |||
2824 | if (Obj.isLE()) | |||
2825 | printAttributes(ELF::SHT_ARM_ATTRIBUTES, | |||
2826 | std::make_unique<ARMAttributeParser>(&W), | |||
2827 | support::little); | |||
2828 | else | |||
2829 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2830 | "ARM objects"); | |||
2831 | break; | |||
2832 | case EM_RISCV: | |||
2833 | if (Obj.isLE()) | |||
2834 | printAttributes(ELF::SHT_RISCV_ATTRIBUTES, | |||
2835 | std::make_unique<RISCVAttributeParser>(&W), | |||
2836 | support::little); | |||
2837 | else | |||
2838 | reportUniqueWarning("attribute printing not implemented for big-endian " | |||
2839 | "RISC-V objects"); | |||
2840 | break; | |||
2841 | case EM_MSP430: | |||
2842 | printAttributes(ELF::SHT_MSP430_ATTRIBUTES, | |||
2843 | std::make_unique<MSP430AttributeParser>(&W), | |||
2844 | support::little); | |||
2845 | break; | |||
2846 | case EM_MIPS: { | |||
2847 | printMipsABIFlags(); | |||
2848 | printMipsOptions(); | |||
2849 | printMipsReginfo(); | |||
2850 | MipsGOTParser<ELFT> Parser(*this); | |||
2851 | if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols())) | |||
2852 | reportUniqueWarning(std::move(E)); | |||
2853 | else if (!Parser.isGotEmpty()) | |||
2854 | printMipsGOT(Parser); | |||
2855 | ||||
2856 | if (Error E = Parser.findPLT(dynamic_table())) | |||
2857 | reportUniqueWarning(std::move(E)); | |||
2858 | else if (!Parser.isPltEmpty()) | |||
2859 | printMipsPLT(Parser); | |||
2860 | break; | |||
2861 | } | |||
2862 | default: | |||
2863 | break; | |||
2864 | } | |||
2865 | } | |||
2866 | ||||
2867 | template <class ELFT> | |||
2868 | void ELFDumper<ELFT>::printAttributes( | |||
2869 | unsigned AttrShType, std::unique_ptr<ELFAttributeParser> AttrParser, | |||
2870 | support::endianness Endianness) { | |||
2871 | 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", 2872, __extension__ __PRETTY_FUNCTION__)) | |||
2872 | "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", 2872, __extension__ __PRETTY_FUNCTION__)); | |||
2873 | DictScope BA(W, "BuildAttributes"); | |||
2874 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
2875 | if (Sec.sh_type != AttrShType) | |||
2876 | continue; | |||
2877 | ||||
2878 | ArrayRef<uint8_t> Contents; | |||
2879 | if (Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
2880 | Obj.getSectionContents(Sec)) { | |||
2881 | Contents = *ContentOrErr; | |||
2882 | if (Contents.empty()) { | |||
2883 | reportUniqueWarning("the " + describe(Sec) + " is empty"); | |||
2884 | continue; | |||
2885 | } | |||
2886 | } else { | |||
2887 | reportUniqueWarning("unable to read the content of the " + describe(Sec) + | |||
2888 | ": " + toString(ContentOrErr.takeError())); | |||
2889 | continue; | |||
2890 | } | |||
2891 | ||||
2892 | W.printHex("FormatVersion", Contents[0]); | |||
2893 | ||||
2894 | if (Error E = AttrParser->parse(Contents, Endianness)) | |||
2895 | reportUniqueWarning("unable to dump attributes from the " + | |||
2896 | describe(Sec) + ": " + toString(std::move(E))); | |||
2897 | } | |||
2898 | } | |||
2899 | ||||
2900 | namespace { | |||
2901 | ||||
2902 | template <class ELFT> class MipsGOTParser { | |||
2903 | public: | |||
2904 | 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; | |||
2905 | using Entry = typename ELFT::Addr; | |||
2906 | using Entries = ArrayRef<Entry>; | |||
2907 | ||||
2908 | const bool IsStatic; | |||
2909 | const ELFFile<ELFT> &Obj; | |||
2910 | const ELFDumper<ELFT> &Dumper; | |||
2911 | ||||
2912 | MipsGOTParser(const ELFDumper<ELFT> &D); | |||
2913 | Error findGOT(Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms); | |||
2914 | Error findPLT(Elf_Dyn_Range DynTable); | |||
2915 | ||||
2916 | bool isGotEmpty() const { return GotEntries.empty(); } | |||
2917 | bool isPltEmpty() const { return PltEntries.empty(); } | |||
2918 | ||||
2919 | uint64_t getGp() const; | |||
2920 | ||||
2921 | const Entry *getGotLazyResolver() const; | |||
2922 | const Entry *getGotModulePointer() const; | |||
2923 | const Entry *getPltLazyResolver() const; | |||
2924 | const Entry *getPltModulePointer() const; | |||
2925 | ||||
2926 | Entries getLocalEntries() const; | |||
2927 | Entries getGlobalEntries() const; | |||
2928 | Entries getOtherEntries() const; | |||
2929 | Entries getPltEntries() const; | |||
2930 | ||||
2931 | uint64_t getGotAddress(const Entry * E) const; | |||
2932 | int64_t getGotOffset(const Entry * E) const; | |||
2933 | const Elf_Sym *getGotSym(const Entry *E) const; | |||
2934 | ||||
2935 | uint64_t getPltAddress(const Entry * E) const; | |||
2936 | const Elf_Sym *getPltSym(const Entry *E) const; | |||
2937 | ||||
2938 | StringRef getPltStrTable() const { return PltStrTable; } | |||
2939 | const Elf_Shdr *getPltSymTable() const { return PltSymTable; } | |||
2940 | ||||
2941 | private: | |||
2942 | const Elf_Shdr *GotSec; | |||
2943 | size_t LocalNum; | |||
2944 | size_t GlobalNum; | |||
2945 | ||||
2946 | const Elf_Shdr *PltSec; | |||
2947 | const Elf_Shdr *PltRelSec; | |||
2948 | const Elf_Shdr *PltSymTable; | |||
2949 | StringRef FileName; | |||
2950 | ||||
2951 | Elf_Sym_Range GotDynSyms; | |||
2952 | StringRef PltStrTable; | |||
2953 | ||||
2954 | Entries GotEntries; | |||
2955 | Entries PltEntries; | |||
2956 | }; | |||
2957 | ||||
2958 | } // end anonymous namespace | |||
2959 | ||||
2960 | template <class ELFT> | |||
2961 | MipsGOTParser<ELFT>::MipsGOTParser(const ELFDumper<ELFT> &D) | |||
2962 | : IsStatic(D.dynamic_table().empty()), Obj(D.getElfObject().getELFFile()), | |||
2963 | Dumper(D), GotSec(nullptr), LocalNum(0), GlobalNum(0), PltSec(nullptr), | |||
2964 | PltRelSec(nullptr), PltSymTable(nullptr), | |||
2965 | FileName(D.getElfObject().getFileName()) {} | |||
2966 | ||||
2967 | template <class ELFT> | |||
2968 | Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable, | |||
2969 | Elf_Sym_Range DynSyms) { | |||
2970 | // See "Global Offset Table" in Chapter 5 in the following document | |||
2971 | // for detailed GOT description. | |||
2972 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
2973 | ||||
2974 | // Find static GOT secton. | |||
2975 | if (IsStatic) { | |||
2976 | GotSec = Dumper.findSectionByName(".got"); | |||
2977 | if (!GotSec) | |||
2978 | return Error::success(); | |||
2979 | ||||
2980 | ArrayRef<uint8_t> Content = | |||
2981 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
2982 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
2983 | Content.size() / sizeof(Entry)); | |||
2984 | LocalNum = GotEntries.size(); | |||
2985 | return Error::success(); | |||
2986 | } | |||
2987 | ||||
2988 | // Lookup dynamic table tags which define the GOT layout. | |||
2989 | std::optional<uint64_t> DtPltGot; | |||
2990 | std::optional<uint64_t> DtLocalGotNum; | |||
2991 | std::optional<uint64_t> DtGotSym; | |||
2992 | for (const auto &Entry : DynTable) { | |||
2993 | switch (Entry.getTag()) { | |||
2994 | case ELF::DT_PLTGOT: | |||
2995 | DtPltGot = Entry.getVal(); | |||
2996 | break; | |||
2997 | case ELF::DT_MIPS_LOCAL_GOTNO: | |||
2998 | DtLocalGotNum = Entry.getVal(); | |||
2999 | break; | |||
3000 | case ELF::DT_MIPS_GOTSYM: | |||
3001 | DtGotSym = Entry.getVal(); | |||
3002 | break; | |||
3003 | } | |||
3004 | } | |||
3005 | ||||
3006 | if (!DtPltGot && !DtLocalGotNum && !DtGotSym) | |||
3007 | return Error::success(); | |||
3008 | ||||
3009 | if (!DtPltGot) | |||
3010 | return createError("cannot find PLTGOT dynamic tag"); | |||
3011 | if (!DtLocalGotNum) | |||
3012 | return createError("cannot find MIPS_LOCAL_GOTNO dynamic tag"); | |||
3013 | if (!DtGotSym) | |||
3014 | return createError("cannot find MIPS_GOTSYM dynamic tag"); | |||
3015 | ||||
3016 | size_t DynSymTotal = DynSyms.size(); | |||
3017 | if (*DtGotSym > DynSymTotal) | |||
3018 | return createError("DT_MIPS_GOTSYM value (" + Twine(*DtGotSym) + | |||
3019 | ") exceeds the number of dynamic symbols (" + | |||
3020 | Twine(DynSymTotal) + ")"); | |||
3021 | ||||
3022 | GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot); | |||
3023 | if (!GotSec) | |||
3024 | return createError("there is no non-empty GOT section at 0x" + | |||
3025 | Twine::utohexstr(*DtPltGot)); | |||
3026 | ||||
3027 | LocalNum = *DtLocalGotNum; | |||
3028 | GlobalNum = DynSymTotal - *DtGotSym; | |||
3029 | ||||
3030 | ArrayRef<uint8_t> Content = | |||
3031 | unwrapOrError(FileName, Obj.getSectionContents(*GotSec)); | |||
3032 | GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), | |||
3033 | Content.size() / sizeof(Entry)); | |||
3034 | GotDynSyms = DynSyms.drop_front(*DtGotSym); | |||
3035 | ||||
3036 | return Error::success(); | |||
3037 | } | |||
3038 | ||||
3039 | template <class ELFT> | |||
3040 | Error MipsGOTParser<ELFT>::findPLT(Elf_Dyn_Range DynTable) { | |||
3041 | // Lookup dynamic table tags which define the PLT layout. | |||
3042 | std::optional<uint64_t> DtMipsPltGot; | |||
3043 | std::optional<uint64_t> DtJmpRel; | |||
3044 | for (const auto &Entry : DynTable) { | |||
3045 | switch (Entry.getTag()) { | |||
3046 | case ELF::DT_MIPS_PLTGOT: | |||
3047 | DtMipsPltGot = Entry.getVal(); | |||
3048 | break; | |||
3049 | case ELF::DT_JMPREL: | |||
3050 | DtJmpRel = Entry.getVal(); | |||
3051 | break; | |||
3052 | } | |||
3053 | } | |||
3054 | ||||
3055 | if (!DtMipsPltGot && !DtJmpRel) | |||
3056 | return Error::success(); | |||
3057 | ||||
3058 | // Find PLT section. | |||
3059 | if (!DtMipsPltGot) | |||
3060 | return createError("cannot find MIPS_PLTGOT dynamic tag"); | |||
3061 | if (!DtJmpRel) | |||
3062 | return createError("cannot find JMPREL dynamic tag"); | |||
3063 | ||||
3064 | PltSec = findNotEmptySectionByAddress(Obj, FileName, *DtMipsPltGot); | |||
3065 | if (!PltSec) | |||
3066 | return createError("there is no non-empty PLTGOT section at 0x" + | |||
3067 | Twine::utohexstr(*DtMipsPltGot)); | |||
3068 | ||||
3069 | PltRelSec = findNotEmptySectionByAddress(Obj, FileName, *DtJmpRel); | |||
3070 | if (!PltRelSec) | |||
3071 | return createError("there is no non-empty RELPLT section at 0x" + | |||
3072 | Twine::utohexstr(*DtJmpRel)); | |||
3073 | ||||
3074 | if (Expected<ArrayRef<uint8_t>> PltContentOrErr = | |||
3075 | Obj.getSectionContents(*PltSec)) | |||
3076 | PltEntries = | |||
3077 | Entries(reinterpret_cast<const Entry *>(PltContentOrErr->data()), | |||
3078 | PltContentOrErr->size() / sizeof(Entry)); | |||
3079 | else | |||
3080 | return createError("unable to read PLTGOT section content: " + | |||
3081 | toString(PltContentOrErr.takeError())); | |||
3082 | ||||
3083 | if (Expected<const Elf_Shdr *> PltSymTableOrErr = | |||
3084 | Obj.getSection(PltRelSec->sh_link)) | |||
3085 | PltSymTable = *PltSymTableOrErr; | |||
3086 | else | |||
3087 | return createError("unable to get a symbol table linked to the " + | |||
3088 | describe(Obj, *PltRelSec) + ": " + | |||
3089 | toString(PltSymTableOrErr.takeError())); | |||
3090 | ||||
3091 | if (Expected<StringRef> StrTabOrErr = | |||
3092 | Obj.getStringTableForSymtab(*PltSymTable)) | |||
3093 | PltStrTable = *StrTabOrErr; | |||
3094 | else | |||
3095 | return createError("unable to get a string table for the " + | |||
3096 | describe(Obj, *PltSymTable) + ": " + | |||
3097 | toString(StrTabOrErr.takeError())); | |||
3098 | ||||
3099 | return Error::success(); | |||
3100 | } | |||
3101 | ||||
3102 | template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const { | |||
3103 | return GotSec->sh_addr + 0x7ff0; | |||
3104 | } | |||
3105 | ||||
3106 | template <class ELFT> | |||
3107 | const typename MipsGOTParser<ELFT>::Entry * | |||
3108 | MipsGOTParser<ELFT>::getGotLazyResolver() const { | |||
3109 | return LocalNum > 0 ? &GotEntries[0] : nullptr; | |||
3110 | } | |||
3111 | ||||
3112 | template <class ELFT> | |||
3113 | const typename MipsGOTParser<ELFT>::Entry * | |||
3114 | MipsGOTParser<ELFT>::getGotModulePointer() const { | |||
3115 | if (LocalNum < 2) | |||
3116 | return nullptr; | |||
3117 | const Entry &E = GotEntries[1]; | |||
3118 | if ((E >> (sizeof(Entry) * 8 - 1)) == 0) | |||
3119 | return nullptr; | |||
3120 | return &E; | |||
3121 | } | |||
3122 | ||||
3123 | template <class ELFT> | |||
3124 | typename MipsGOTParser<ELFT>::Entries | |||
3125 | MipsGOTParser<ELFT>::getLocalEntries() const { | |||
3126 | size_t Skip = getGotModulePointer() ? 2 : 1; | |||
3127 | if (LocalNum - Skip <= 0) | |||
3128 | return Entries(); | |||
3129 | return GotEntries.slice(Skip, LocalNum - Skip); | |||
3130 | } | |||
3131 | ||||
3132 | template <class ELFT> | |||
3133 | typename MipsGOTParser<ELFT>::Entries | |||
3134 | MipsGOTParser<ELFT>::getGlobalEntries() const { | |||
3135 | if (GlobalNum == 0) | |||
3136 | return Entries(); | |||
3137 | return GotEntries.slice(LocalNum, GlobalNum); | |||
3138 | } | |||
3139 | ||||
3140 | template <class ELFT> | |||
3141 | typename MipsGOTParser<ELFT>::Entries | |||
3142 | MipsGOTParser<ELFT>::getOtherEntries() const { | |||
3143 | size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum; | |||
3144 | if (OtherNum == 0) | |||
3145 | return Entries(); | |||
3146 | return GotEntries.slice(LocalNum + GlobalNum, OtherNum); | |||
3147 | } | |||
3148 | ||||
3149 | template <class ELFT> | |||
3150 | uint64_t MipsGOTParser<ELFT>::getGotAddress(const Entry *E) const { | |||
3151 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
3152 | return GotSec->sh_addr + Offset; | |||
3153 | } | |||
3154 | ||||
3155 | template <class ELFT> | |||
3156 | int64_t MipsGOTParser<ELFT>::getGotOffset(const Entry *E) const { | |||
3157 | int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); | |||
3158 | return Offset - 0x7ff0; | |||
3159 | } | |||
3160 | ||||
3161 | template <class ELFT> | |||
3162 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
3163 | MipsGOTParser<ELFT>::getGotSym(const Entry *E) const { | |||
3164 | int64_t Offset = std::distance(GotEntries.data(), E); | |||
3165 | return &GotDynSyms[Offset - LocalNum]; | |||
3166 | } | |||
3167 | ||||
3168 | template <class ELFT> | |||
3169 | const typename MipsGOTParser<ELFT>::Entry * | |||
3170 | MipsGOTParser<ELFT>::getPltLazyResolver() const { | |||
3171 | return PltEntries.empty() ? nullptr : &PltEntries[0]; | |||
3172 | } | |||
3173 | ||||
3174 | template <class ELFT> | |||
3175 | const typename MipsGOTParser<ELFT>::Entry * | |||
3176 | MipsGOTParser<ELFT>::getPltModulePointer() const { | |||
3177 | return PltEntries.size() < 2 ? nullptr : &PltEntries[1]; | |||
3178 | } | |||
3179 | ||||
3180 | template <class ELFT> | |||
3181 | typename MipsGOTParser<ELFT>::Entries | |||
3182 | MipsGOTParser<ELFT>::getPltEntries() const { | |||
3183 | if (PltEntries.size() <= 2) | |||
3184 | return Entries(); | |||
3185 | return PltEntries.slice(2, PltEntries.size() - 2); | |||
3186 | } | |||
3187 | ||||
3188 | template <class ELFT> | |||
3189 | uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const { | |||
3190 | int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry); | |||
3191 | return PltSec->sh_addr + Offset; | |||
3192 | } | |||
3193 | ||||
3194 | template <class ELFT> | |||
3195 | const typename MipsGOTParser<ELFT>::Elf_Sym * | |||
3196 | MipsGOTParser<ELFT>::getPltSym(const Entry *E) const { | |||
3197 | int64_t Offset = std::distance(getPltEntries().data(), E); | |||
3198 | if (PltRelSec->sh_type == ELF::SHT_REL) { | |||
3199 | Elf_Rel_Range Rels = unwrapOrError(FileName, Obj.rels(*PltRelSec)); | |||
3200 | return unwrapOrError(FileName, | |||
3201 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
3202 | } else { | |||
3203 | Elf_Rela_Range Rels = unwrapOrError(FileName, Obj.relas(*PltRelSec)); | |||
3204 | return unwrapOrError(FileName, | |||
3205 | Obj.getRelocationSymbol(Rels[Offset], PltSymTable)); | |||
3206 | } | |||
3207 | } | |||
3208 | ||||
3209 | const EnumEntry<unsigned> ElfMipsISAExtType[] = { | |||
3210 | {"None", Mips::AFL_EXT_NONE}, | |||
3211 | {"Broadcom SB-1", Mips::AFL_EXT_SB1}, | |||
3212 | {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, | |||
3213 | {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, | |||
3214 | {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, | |||
3215 | {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, | |||
3216 | {"LSI R4010", Mips::AFL_EXT_4010}, | |||
3217 | {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, | |||
3218 | {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, | |||
3219 | {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, | |||
3220 | {"MIPS R4650", Mips::AFL_EXT_4650}, | |||
3221 | {"MIPS R5900", Mips::AFL_EXT_5900}, | |||
3222 | {"MIPS R10000", Mips::AFL_EXT_10000}, | |||
3223 | {"NEC VR4100", Mips::AFL_EXT_4100}, | |||
3224 | {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, | |||
3225 | {"NEC VR4120", Mips::AFL_EXT_4120}, | |||
3226 | {"NEC VR5400", Mips::AFL_EXT_5400}, | |||
3227 | {"NEC VR5500", Mips::AFL_EXT_5500}, | |||
3228 | {"RMI Xlr", Mips::AFL_EXT_XLR}, | |||
3229 | {"Toshiba R3900", Mips::AFL_EXT_3900} | |||
3230 | }; | |||
3231 | ||||
3232 | const EnumEntry<unsigned> ElfMipsASEFlags[] = { | |||
3233 | {"DSP", Mips::AFL_ASE_DSP}, | |||
3234 | {"DSPR2", Mips::AFL_ASE_DSPR2}, | |||
3235 | {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, | |||
3236 | {"MCU", Mips::AFL_ASE_MCU}, | |||
3237 | {"MDMX", Mips::AFL_ASE_MDMX}, | |||
3238 | {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, | |||
3239 | {"MT", Mips::AFL_ASE_MT}, | |||
3240 | {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, | |||
3241 | {"VZ", Mips::AFL_ASE_VIRT}, | |||
3242 | {"MSA", Mips::AFL_ASE_MSA}, | |||
3243 | {"MIPS16", Mips::AFL_ASE_MIPS16}, | |||
3244 | {"microMIPS", Mips::AFL_ASE_MICROMIPS}, | |||
3245 | {"XPA", Mips::AFL_ASE_XPA}, | |||
3246 | {"CRC", Mips::AFL_ASE_CRC}, | |||
3247 | {"GINV", Mips::AFL_ASE_GINV}, | |||
3248 | }; | |||
3249 | ||||
3250 | const EnumEntry<unsigned> ElfMipsFpABIType[] = { | |||
3251 | {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, | |||
3252 | {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, | |||
3253 | {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, | |||
3254 | {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, | |||
3255 | {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", | |||
3256 | Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, | |||
3257 | {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, | |||
3258 | {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, | |||
3259 | {"Hard float compat (32-bit CPU, 64-bit FPU)", | |||
3260 | Mips::Val_GNU_MIPS_ABI_FP_64A} | |||
3261 | }; | |||
3262 | ||||
3263 | static const EnumEntry<unsigned> ElfMipsFlags1[] { | |||
3264 | {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, | |||
3265 | }; | |||
3266 | ||||
3267 | static int getMipsRegisterSize(uint8_t Flag) { | |||
3268 | switch (Flag) { | |||
3269 | case Mips::AFL_REG_NONE: | |||
3270 | return 0; | |||
3271 | case Mips::AFL_REG_32: | |||
3272 | return 32; | |||
3273 | case Mips::AFL_REG_64: | |||
3274 | return 64; | |||
3275 | case Mips::AFL_REG_128: | |||
3276 | return 128; | |||
3277 | default: | |||
3278 | return -1; | |||
3279 | } | |||
3280 | } | |||
3281 | ||||
3282 | template <class ELFT> | |||
3283 | static void printMipsReginfoData(ScopedPrinter &W, | |||
3284 | const Elf_Mips_RegInfo<ELFT> &Reginfo) { | |||
3285 | W.printHex("GP", Reginfo.ri_gp_value); | |||
3286 | W.printHex("General Mask", Reginfo.ri_gprmask); | |||
3287 | W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); | |||
3288 | W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); | |||
3289 | W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); | |||
3290 | W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); | |||
3291 | } | |||
3292 | ||||
3293 | template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { | |||
3294 | const Elf_Shdr *RegInfoSec = findSectionByName(".reginfo"); | |||
3295 | if (!RegInfoSec) { | |||
3296 | W.startLine() << "There is no .reginfo section in the file.\n"; | |||
3297 | return; | |||
3298 | } | |||
3299 | ||||
3300 | Expected<ArrayRef<uint8_t>> ContentsOrErr = | |||
3301 | Obj.getSectionContents(*RegInfoSec); | |||
3302 | if (!ContentsOrErr) { | |||
3303 | this->reportUniqueWarning( | |||
3304 | "unable to read the content of the .reginfo section (" + | |||
3305 | describe(*RegInfoSec) + "): " + toString(ContentsOrErr.takeError())); | |||
3306 | return; | |||
3307 | } | |||
3308 | ||||
3309 | if (ContentsOrErr->size() < sizeof(Elf_Mips_RegInfo<ELFT>)) { | |||
3310 | this->reportUniqueWarning("the .reginfo section has an invalid size (0x" + | |||
3311 | Twine::utohexstr(ContentsOrErr->size()) + ")"); | |||
3312 | return; | |||
3313 | } | |||
3314 | ||||
3315 | DictScope GS(W, "MIPS RegInfo"); | |||
3316 | printMipsReginfoData(W, *reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>( | |||
3317 | ContentsOrErr->data())); | |||
3318 | } | |||
3319 | ||||
3320 | template <class ELFT> | |||
3321 | static Expected<const Elf_Mips_Options<ELFT> *> | |||
3322 | readMipsOptions(const uint8_t *SecBegin, ArrayRef<uint8_t> &SecData, | |||
3323 | bool &IsSupported) { | |||
3324 | if (SecData.size() < sizeof(Elf_Mips_Options<ELFT>)) | |||
3325 | return createError("the .MIPS.options section has an invalid size (0x" + | |||
3326 | Twine::utohexstr(SecData.size()) + ")"); | |||
3327 | ||||
3328 | const Elf_Mips_Options<ELFT> *O = | |||
3329 | reinterpret_cast<const Elf_Mips_Options<ELFT> *>(SecData.data()); | |||
3330 | const uint8_t Size = O->size; | |||
3331 | if (Size > SecData.size()) { | |||
3332 | const uint64_t Offset = SecData.data() - SecBegin; | |||
3333 | const uint64_t SecSize = Offset + SecData.size(); | |||
3334 | return createError("a descriptor of size 0x" + Twine::utohexstr(Size) + | |||
3335 | " at offset 0x" + Twine::utohexstr(Offset) + | |||
3336 | " goes past the end of the .MIPS.options " | |||
3337 | "section of size 0x" + | |||
3338 | Twine::utohexstr(SecSize)); | |||
3339 | } | |||
3340 | ||||
3341 | IsSupported = O->kind == ODK_REGINFO; | |||
3342 | const size_t ExpectedSize = | |||
3343 | sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>); | |||
3344 | ||||
3345 | if (IsSupported) | |||
3346 | if (Size < ExpectedSize) | |||
3347 | return createError( | |||
3348 | "a .MIPS.options entry of kind " + | |||
3349 | Twine(getElfMipsOptionsOdkType(O->kind)) + | |||
3350 | " has an invalid size (0x" + Twine::utohexstr(Size) + | |||
3351 | "), the expected size is 0x" + Twine::utohexstr(ExpectedSize)); | |||
3352 | ||||
3353 | SecData = SecData.drop_front(Size); | |||
3354 | return O; | |||
3355 | } | |||
3356 | ||||
3357 | template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() { | |||
3358 | const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options"); | |||
3359 | if (!MipsOpts) { | |||
3360 | W.startLine() << "There is no .MIPS.options section in the file.\n"; | |||
3361 | return; | |||
3362 | } | |||
3363 | ||||
3364 | DictScope GS(W, "MIPS Options"); | |||
3365 | ||||
3366 | ArrayRef<uint8_t> Data = | |||
3367 | unwrapOrError(ObjF.getFileName(), Obj.getSectionContents(*MipsOpts)); | |||
3368 | const uint8_t *const SecBegin = Data.begin(); | |||
3369 | while (!Data.empty()) { | |||
3370 | bool IsSupported; | |||
3371 | Expected<const Elf_Mips_Options<ELFT> *> OptsOrErr = | |||
3372 | readMipsOptions<ELFT>(SecBegin, Data, IsSupported); | |||
3373 | if (!OptsOrErr) { | |||
3374 | reportUniqueWarning(OptsOrErr.takeError()); | |||
3375 | break; | |||
3376 | } | |||
3377 | ||||
3378 | unsigned Kind = (*OptsOrErr)->kind; | |||
3379 | const char *Type = getElfMipsOptionsOdkType(Kind); | |||
3380 | if (!IsSupported) { | |||
3381 | W.startLine() << "Unsupported MIPS options tag: " << Type << " (" << Kind | |||
3382 | << ")\n"; | |||
3383 | continue; | |||
3384 | } | |||
3385 | ||||
3386 | DictScope GS(W, Type); | |||
3387 | if (Kind == ODK_REGINFO) | |||
3388 | printMipsReginfoData(W, (*OptsOrErr)->getRegInfo()); | |||
3389 | else | |||
3390 | llvm_unreachable("unexpected .MIPS.options section descriptor kind")::llvm::llvm_unreachable_internal("unexpected .MIPS.options section descriptor kind" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 3390); | |||
3391 | } | |||
3392 | } | |||
3393 | ||||
3394 | template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { | |||
3395 | const Elf_Shdr *StackMapSection = findSectionByName(".llvm_stackmaps"); | |||
3396 | if (!StackMapSection) | |||
3397 | return; | |||
3398 | ||||
3399 | auto Warn = [&](Error &&E) { | |||
3400 | this->reportUniqueWarning("unable to read the stack map from " + | |||
3401 | describe(*StackMapSection) + ": " + | |||
3402 | toString(std::move(E))); | |||
3403 | }; | |||
3404 | ||||
3405 | Expected<ArrayRef<uint8_t>> ContentOrErr = | |||
3406 | Obj.getSectionContents(*StackMapSection); | |||
3407 | if (!ContentOrErr) { | |||
3408 | Warn(ContentOrErr.takeError()); | |||
3409 | return; | |||
3410 | } | |||
3411 | ||||
3412 | if (Error E = StackMapParser<ELFT::TargetEndianness>::validateHeader( | |||
3413 | *ContentOrErr)) { | |||
3414 | Warn(std::move(E)); | |||
3415 | return; | |||
3416 | } | |||
3417 | ||||
3418 | prettyPrintStackMap(W, StackMapParser<ELFT::TargetEndianness>(*ContentOrErr)); | |||
3419 | } | |||
3420 | ||||
3421 | template <class ELFT> | |||
3422 | void ELFDumper<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex, | |||
3423 | const Elf_Shdr &Sec, const Elf_Shdr *SymTab) { | |||
3424 | Expected<RelSymbol<ELFT>> Target = getRelocationTarget(R, SymTab); | |||
3425 | if (!Target) | |||
3426 | reportUniqueWarning("unable to print relocation " + Twine(RelIndex) + | |||
3427 | " in " + describe(Sec) + ": " + | |||
3428 | toString(Target.takeError())); | |||
3429 | else | |||
3430 | printRelRelaReloc(R, *Target); | |||
3431 | } | |||
3432 | ||||
3433 | template <class ELFT> | |||
3434 | std::vector<EnumEntry<unsigned>> | |||
3435 | ELFDumper<ELFT>::getOtherFlagsFromSymbol(const Elf_Ehdr &Header, | |||
3436 | const Elf_Sym &Symbol) const { | |||
3437 | std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags), | |||
3438 | std::end(ElfSymOtherFlags)); | |||
3439 | if (Header.e_machine == EM_MIPS) { | |||
3440 | // Someone in their infinite wisdom decided to make STO_MIPS_MIPS16 | |||
3441 | // flag overlap with other ST_MIPS_xxx flags. So consider both | |||
3442 | // cases separately. | |||
3443 | if ((Symbol.st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16) | |||
3444 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
3445 | std::begin(ElfMips16SymOtherFlags), | |||
3446 | std::end(ElfMips16SymOtherFlags)); | |||
3447 | else | |||
3448 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
3449 | std::begin(ElfMipsSymOtherFlags), | |||
3450 | std::end(ElfMipsSymOtherFlags)); | |||
3451 | } else if (Header.e_machine == EM_AARCH64) { | |||
3452 | SymOtherFlags.insert(SymOtherFlags.end(), | |||
3453 | std::begin(ElfAArch64SymOtherFlags), | |||
3454 | std::end(ElfAArch64SymOtherFlags)); | |||
3455 | } else if (Header.e_machine == EM_RISCV) { | |||
3456 | SymOtherFlags.insert(SymOtherFlags.end(), std::begin(ElfRISCVSymOtherFlags), | |||
3457 | std::end(ElfRISCVSymOtherFlags)); | |||
3458 | } | |||
3459 | return SymOtherFlags; | |||
3460 | } | |||
3461 | ||||
3462 | static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, | |||
3463 | StringRef Str2) { | |||
3464 | OS.PadToColumn(2u); | |||
3465 | OS << Str1; | |||
3466 | OS.PadToColumn(37u); | |||
3467 | OS << Str2 << "\n"; | |||
3468 | OS.flush(); | |||
3469 | } | |||
3470 | ||||
3471 | template <class ELFT> | |||
3472 | static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj, | |||
3473 | StringRef FileName) { | |||
3474 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3475 | if (ElfHeader.e_shnum != 0) | |||
3476 | return to_string(ElfHeader.e_shnum); | |||
3477 | ||||
3478 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3479 | if (!ArrOrErr) { | |||
3480 | // In this case we can ignore an error, because we have already reported a | |||
3481 | // warning about the broken section header table earlier. | |||
3482 | consumeError(ArrOrErr.takeError()); | |||
3483 | return "<?>"; | |||
3484 | } | |||
3485 | ||||
3486 | if (ArrOrErr->empty()) | |||
3487 | return "0"; | |||
3488 | return "0 (" + to_string((*ArrOrErr)[0].sh_size) + ")"; | |||
3489 | } | |||
3490 | ||||
3491 | template <class ELFT> | |||
3492 | static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> &Obj, | |||
3493 | StringRef FileName) { | |||
3494 | const typename ELFT::Ehdr &ElfHeader = Obj.getHeader(); | |||
3495 | if (ElfHeader.e_shstrndx != SHN_XINDEX) | |||
3496 | return to_string(ElfHeader.e_shstrndx); | |||
3497 | ||||
3498 | Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections(); | |||
3499 | if (!ArrOrErr) { | |||
3500 | // In this case we can ignore an error, because we have already reported a | |||
3501 | // warning about the broken section header table earlier. | |||
3502 | consumeError(ArrOrErr.takeError()); | |||
3503 | return "<?>"; | |||
3504 | } | |||
3505 | ||||
3506 | if (ArrOrErr->empty()) | |||
3507 | return "65535 (corrupt: out of range)"; | |||
3508 | return to_string(ElfHeader.e_shstrndx) + " (" + | |||
3509 | to_string((*ArrOrErr)[0].sh_link) + ")"; | |||
3510 | } | |||
3511 | ||||
3512 | static const EnumEntry<unsigned> *getObjectFileEnumEntry(unsigned Type) { | |||
3513 | auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) { | |||
3514 | return E.Value == Type; | |||
3515 | }); | |||
3516 | if (It != ArrayRef(ElfObjectFileType).end()) | |||
3517 | return It; | |||
3518 | return nullptr; | |||
3519 | } | |||
3520 | ||||
3521 | template <class ELFT> | |||
3522 | void GNUELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
3523 | ArrayRef<std::string> InputFilenames, | |||
3524 | const Archive *A) { | |||
3525 | if (InputFilenames.size() > 1 || A) { | |||
3526 | this->W.startLine() << "\n"; | |||
3527 | this->W.printString("File", FileStr); | |||
3528 | } | |||
3529 | } | |||
3530 | ||||
3531 | template <class ELFT> void GNUELFDumper<ELFT>::printFileHeaders() { | |||
3532 | const Elf_Ehdr &e = this->Obj.getHeader(); | |||
3533 | OS << "ELF Header:\n"; | |||
3534 | OS << " Magic: "; | |||
3535 | std::string Str; | |||
3536 | for (int i = 0; i < ELF::EI_NIDENT; i++) | |||
3537 | OS << format(" %02x", static_cast<int>(e.e_ident[i])); | |||
3538 | OS << "\n"; | |||
3539 | Str = enumToString(e.e_ident[ELF::EI_CLASS], ArrayRef(ElfClass)); | |||
3540 | printFields(OS, "Class:", Str); | |||
3541 | Str = enumToString(e.e_ident[ELF::EI_DATA], ArrayRef(ElfDataEncoding)); | |||
3542 | printFields(OS, "Data:", Str); | |||
3543 | OS.PadToColumn(2u); | |||
3544 | OS << "Version:"; | |||
3545 | OS.PadToColumn(37u); | |||
3546 | OS << utohexstr(e.e_ident[ELF::EI_VERSION]); | |||
3547 | if (e.e_version == ELF::EV_CURRENT) | |||
3548 | OS << " (current)"; | |||
3549 | OS << "\n"; | |||
3550 | Str = enumToString(e.e_ident[ELF::EI_OSABI], ArrayRef(ElfOSABI)); | |||
3551 | printFields(OS, "OS/ABI:", Str); | |||
3552 | printFields(OS, | |||
3553 | "ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION])); | |||
3554 | ||||
3555 | if (const EnumEntry<unsigned> *E = getObjectFileEnumEntry(e.e_type)) { | |||
3556 | Str = E->AltName.str(); | |||
3557 | } else { | |||
3558 | if (e.e_type >= ET_LOPROC) | |||
3559 | Str = "Processor Specific: (" + utohexstr(e.e_type, /*LowerCase=*/true) + ")"; | |||
3560 | else if (e.e_type >= ET_LOOS) | |||
3561 | Str = "OS Specific: (" + utohexstr(e.e_type, /*LowerCase=*/true) + ")"; | |||
3562 | else | |||
3563 | Str = "<unknown>: " + utohexstr(e.e_type, /*LowerCase=*/true); | |||
3564 | } | |||
3565 | printFields(OS, "Type:", Str); | |||
3566 | ||||
3567 | Str = enumToString(e.e_machine, ArrayRef(ElfMachineType)); | |||
3568 | printFields(OS, "Machine:", Str); | |||
3569 | Str = "0x" + utohexstr(e.e_version); | |||
3570 | printFields(OS, "Version:", Str); | |||
3571 | Str = "0x" + utohexstr(e.e_entry); | |||
3572 | printFields(OS, "Entry point address:", Str); | |||
3573 | Str = to_string(e.e_phoff) + " (bytes into file)"; | |||
3574 | printFields(OS, "Start of program headers:", Str); | |||
3575 | Str = to_string(e.e_shoff) + " (bytes into file)"; | |||
3576 | printFields(OS, "Start of section headers:", Str); | |||
3577 | std::string ElfFlags; | |||
3578 | if (e.e_machine == EM_MIPS) | |||
3579 | ElfFlags = printFlags( | |||
3580 | e.e_flags, ArrayRef(ElfHeaderMipsFlags), unsigned(ELF::EF_MIPS_ARCH), | |||
3581 | unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_MACH)); | |||
3582 | else if (e.e_machine == EM_RISCV) | |||
3583 | ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderRISCVFlags)); | |||
3584 | else if (e.e_machine == EM_AVR) | |||
3585 | ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderAVRFlags), | |||
3586 | unsigned(ELF::EF_AVR_ARCH_MASK)); | |||
3587 | else if (e.e_machine == EM_LOONGARCH) | |||
3588 | ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderLoongArchFlags), | |||
3589 | unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), | |||
3590 | unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); | |||
3591 | else if (e.e_machine == EM_XTENSA) | |||
3592 | ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderXtensaFlags), | |||
3593 | unsigned(ELF::EF_XTENSA_MACH)); | |||
3594 | Str = "0x" + utohexstr(e.e_flags); | |||
3595 | if (!ElfFlags.empty()) | |||
3596 | Str = Str + ", " + ElfFlags; | |||
3597 | printFields(OS, "Flags:", Str); | |||
3598 | Str = to_string(e.e_ehsize) + " (bytes)"; | |||
3599 | printFields(OS, "Size of this header:", Str); | |||
3600 | Str = to_string(e.e_phentsize) + " (bytes)"; | |||
3601 | printFields(OS, "Size of program headers:", Str); | |||
3602 | Str = to_string(e.e_phnum); | |||
3603 | printFields(OS, "Number of program headers:", Str); | |||
3604 | Str = to_string(e.e_shentsize) + " (bytes)"; | |||
3605 | printFields(OS, "Size of section headers:", Str); | |||
3606 | Str = getSectionHeadersNumString(this->Obj, this->FileName); | |||
3607 | printFields(OS, "Number of section headers:", Str); | |||
3608 | Str = getSectionHeaderTableIndexString(this->Obj, this->FileName); | |||
3609 | printFields(OS, "Section header string table index:", Str); | |||
3610 | } | |||
3611 | ||||
3612 | template <class ELFT> std::vector<GroupSection> ELFDumper<ELFT>::getGroups() { | |||
3613 | auto GetSignature = [&](const Elf_Sym &Sym, unsigned SymNdx, | |||
3614 | const Elf_Shdr &Symtab) -> StringRef { | |||
3615 | Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(Symtab); | |||
3616 | if (!StrTableOrErr) { | |||
3617 | reportUniqueWarning("unable to get the string table for " + | |||
3618 | describe(Symtab) + ": " + | |||
3619 | toString(StrTableOrErr.takeError())); | |||
3620 | return "<?>"; | |||
3621 | } | |||
3622 | ||||
3623 | StringRef Strings = *StrTableOrErr; | |||
3624 | if (Sym.st_name >= Strings.size()) { | |||
3625 | reportUniqueWarning("unable to get the name of the symbol with index " + | |||
3626 | Twine(SymNdx) + ": st_name (0x" + | |||
3627 | Twine::utohexstr(Sym.st_name) + | |||
3628 | ") is past the end of the string table of size 0x" + | |||
3629 | Twine::utohexstr(Strings.size())); | |||
3630 | return "<?>"; | |||
3631 | } | |||
3632 | ||||
3633 | return StrTableOrErr->data() + Sym.st_name; | |||
3634 | }; | |||
3635 | ||||
3636 | std::vector<GroupSection> Ret; | |||
3637 | uint64_t I = 0; | |||
3638 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
3639 | ++I; | |||
3640 | if (Sec.sh_type != ELF::SHT_GROUP) | |||
3641 | continue; | |||
3642 | ||||
3643 | StringRef Signature = "<?>"; | |||
3644 | if (Expected<const Elf_Shdr *> SymtabOrErr = Obj.getSection(Sec.sh_link)) { | |||
3645 | if (Expected<const Elf_Sym *> SymOrErr = | |||
3646 | Obj.template getEntry<Elf_Sym>(**SymtabOrErr, Sec.sh_info)) | |||
3647 | Signature = GetSignature(**SymOrErr, Sec.sh_info, **SymtabOrErr); | |||
3648 | else | |||
3649 | reportUniqueWarning("unable to get the signature symbol for " + | |||
3650 | describe(Sec) + ": " + | |||
3651 | toString(SymOrErr.takeError())); | |||
3652 | } else { | |||
3653 | reportUniqueWarning("unable to get the symbol table for " + | |||
3654 | describe(Sec) + ": " + | |||
3655 | toString(SymtabOrErr.takeError())); | |||
3656 | } | |||
3657 | ||||
3658 | ArrayRef<Elf_Word> Data; | |||
3659 | if (Expected<ArrayRef<Elf_Word>> ContentsOrErr = | |||
3660 | Obj.template getSectionContentsAsArray<Elf_Word>(Sec)) { | |||
3661 | if (ContentsOrErr->empty()) | |||
3662 | reportUniqueWarning("unable to read the section group flag from the " + | |||
3663 | describe(Sec) + ": the section is empty"); | |||
3664 | else | |||
3665 | Data = *ContentsOrErr; | |||
3666 | } else { | |||
3667 | reportUniqueWarning("unable to get the content of the " + describe(Sec) + | |||
3668 | ": " + toString(ContentsOrErr.takeError())); | |||
3669 | } | |||
3670 | ||||
3671 | Ret.push_back({getPrintableSectionName(Sec), | |||
3672 | maybeDemangle(Signature), | |||
3673 | Sec.sh_name, | |||
3674 | I - 1, | |||
3675 | Sec.sh_link, | |||
3676 | Sec.sh_info, | |||
3677 | Data.empty() ? Elf_Word(0) : Data[0], | |||
3678 | {}}); | |||
3679 | ||||
3680 | if (Data.empty()) | |||
3681 | continue; | |||
3682 | ||||
3683 | std::vector<GroupMember> &GM = Ret.back().Members; | |||
3684 | for (uint32_t Ndx : Data.slice(1)) { | |||
3685 | if (Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(Ndx)) { | |||
3686 | GM.push_back({getPrintableSectionName(**SecOrErr), Ndx}); | |||
3687 | } else { | |||
3688 | reportUniqueWarning("unable to get the section with index " + | |||
3689 | Twine(Ndx) + " when dumping the " + describe(Sec) + | |||
3690 | ": " + toString(SecOrErr.takeError())); | |||
3691 | GM.push_back({"<?>", Ndx}); | |||
3692 | } | |||
3693 | } | |||
3694 | } | |||
3695 | return Ret; | |||
3696 | } | |||
3697 | ||||
3698 | static DenseMap<uint64_t, const GroupSection *> | |||
3699 | mapSectionsToGroups(ArrayRef<GroupSection> Groups) { | |||
3700 | DenseMap<uint64_t, const GroupSection *> Ret; | |||
3701 | for (const GroupSection &G : Groups) | |||
3702 | for (const GroupMember &GM : G.Members) | |||
3703 | Ret.insert({GM.Index, &G}); | |||
3704 | return Ret; | |||
3705 | } | |||
3706 | ||||
3707 | template <class ELFT> void GNUELFDumper<ELFT>::printGroupSections() { | |||
3708 | std::vector<GroupSection> V = this->getGroups(); | |||
3709 | DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); | |||
3710 | for (const GroupSection &G : V) { | |||
3711 | OS << "\n" | |||
3712 | << getGroupType(G.Type) << " group section [" | |||
3713 | << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature | |||
3714 | << "] contains " << G.Members.size() << " sections:\n" | |||
3715 | << " [Index] Name\n"; | |||
3716 | for (const GroupMember &GM : G.Members) { | |||
3717 | const GroupSection *MainGroup = Map[GM.Index]; | |||
3718 | if (MainGroup != &G) | |||
3719 | this->reportUniqueWarning( | |||
3720 | "section with index " + Twine(GM.Index) + | |||
3721 | ", included in the group section with index " + | |||
3722 | Twine(MainGroup->Index) + | |||
3723 | ", was also found in the group section with index " + | |||
3724 | Twine(G.Index)); | |||
3725 | OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n"; | |||
3726 | } | |||
3727 | } | |||
3728 | ||||
3729 | if (V.empty()) | |||
3730 | OS << "There are no section groups in this file.\n"; | |||
3731 | } | |||
3732 | ||||
3733 | template <class ELFT> | |||
3734 | void GNUELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) { | |||
3735 | OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n"; | |||
3736 | } | |||
3737 | ||||
3738 | template <class ELFT> | |||
3739 | void GNUELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R, | |||
3740 | const RelSymbol<ELFT> &RelSym) { | |||
3741 | // First two fields are bit width dependent. The rest of them are fixed width. | |||
3742 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
3743 | Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; | |||
3744 | unsigned Width = ELFT::Is64Bits ? 16 : 8; | |||
3745 | ||||
3746 | Fields[0].Str = to_string(format_hex_no_prefix(R.Offset, Width)); | |||
3747 | Fields[1].Str = to_string(format_hex_no_prefix(R.Info, Width)); | |||
3748 | ||||
3749 | SmallString<32> RelocName; | |||
3750 | this->Obj.getRelocationTypeName(R.Type, RelocName); | |||
3751 | Fields[2].Str = RelocName.c_str(); | |||
3752 | ||||
3753 | if (RelSym.Sym) | |||
3754 | Fields[3].Str = | |||
3755 | to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width)); | |||
3756 | ||||
3757 | Fields[4].Str = std::string(RelSym.Name); | |||
3758 | for (const Field &F : Fields) | |||
3759 | printField(F); | |||
3760 | ||||
3761 | std::string Addend; | |||
3762 | if (std::optional<int64_t> A = R.Addend) { | |||
3763 | int64_t RelAddend = *A; | |||
3764 | if (!RelSym.Name.empty()) { | |||
3765 | if (RelAddend < 0) { | |||
3766 | Addend = " - "; | |||
3767 | RelAddend = std::abs(RelAddend); | |||
3768 | } else { | |||
3769 | Addend = " + "; | |||
3770 | } | |||
3771 | } | |||
3772 | Addend += utohexstr(RelAddend, /*LowerCase=*/true); | |||
3773 | } | |||
3774 | OS << Addend << "\n"; | |||
3775 | } | |||
3776 | ||||
3777 | template <class ELFT> | |||
3778 | static void printRelocHeaderFields(formatted_raw_ostream &OS, unsigned SType) { | |||
3779 | bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA; | |||
3780 | bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR; | |||
3781 | if (ELFT::Is64Bits) | |||
3782 | OS << " "; | |||
3783 | else | |||
3784 | OS << " "; | |||
3785 | if (IsRelr && opts::RawRelr) | |||
3786 | OS << "Data "; | |||
3787 | else | |||
3788 | OS << "Offset"; | |||
3789 | if (ELFT::Is64Bits) | |||
3790 | OS << " Info Type" | |||
3791 | << " Symbol's Value Symbol's Name"; | |||
3792 | else | |||
3793 | OS << " Info Type Sym. Value Symbol's Name"; | |||
3794 | if (IsRela) | |||
3795 | OS << " + Addend"; | |||
3796 | OS << "\n"; | |||
3797 | } | |||
3798 | ||||
3799 | template <class ELFT> | |||
3800 | void GNUELFDumper<ELFT>::printDynamicRelocHeader(unsigned Type, StringRef Name, | |||
3801 | const DynRegionInfo &Reg) { | |||
3802 | uint64_t Offset = Reg.Addr - this->Obj.base(); | |||
3803 | OS << "\n'" << Name.str().c_str() << "' relocation section at offset 0x" | |||
3804 | << utohexstr(Offset, /*LowerCase=*/true) << " contains " << Reg.Size << " bytes:\n"; | |||
3805 | printRelocHeaderFields<ELFT>(OS, Type); | |||
3806 | } | |||
3807 | ||||
3808 | template <class ELFT> | |||
3809 | static bool isRelocationSec(const typename ELFT::Shdr &Sec) { | |||
3810 | return Sec.sh_type == ELF::SHT_REL || Sec.sh_type == ELF::SHT_RELA || | |||
3811 | Sec.sh_type == ELF::SHT_RELR || Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3812 | Sec.sh_type == ELF::SHT_ANDROID_RELA || | |||
3813 | Sec.sh_type == ELF::SHT_ANDROID_RELR; | |||
3814 | } | |||
3815 | ||||
3816 | template <class ELFT> void GNUELFDumper<ELFT>::printRelocations() { | |||
3817 | auto GetEntriesNum = [&](const Elf_Shdr &Sec) -> Expected<size_t> { | |||
3818 | // Android's packed relocation section needs to be unpacked first | |||
3819 | // to get the actual number of entries. | |||
3820 | if (Sec.sh_type == ELF::SHT_ANDROID_REL || | |||
3821 | Sec.sh_type == ELF::SHT_ANDROID_RELA) { | |||
3822 | Expected<std::vector<typename ELFT::Rela>> RelasOrErr = | |||
3823 | this->Obj.android_relas(Sec); | |||
3824 | if (!RelasOrErr) | |||
3825 | return RelasOrErr.takeError(); | |||
3826 | return RelasOrErr->size(); | |||
3827 | } | |||
3828 | ||||
3829 | if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR || | |||
3830 | Sec.sh_type == ELF::SHT_ANDROID_RELR)) { | |||
3831 | Expected<Elf_Relr_Range> RelrsOrErr = this->Obj.relrs(Sec); | |||
3832 | if (!RelrsOrErr) | |||
3833 | return RelrsOrErr.takeError(); | |||
3834 | return this->Obj.decode_relrs(*RelrsOrErr).size(); | |||
3835 | } | |||
3836 | ||||
3837 | return Sec.getEntityCount(); | |||
3838 | }; | |||
3839 | ||||
3840 | bool HasRelocSections = false; | |||
3841 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
3842 | if (!isRelocationSec<ELFT>(Sec)) | |||
3843 | continue; | |||
3844 | HasRelocSections = true; | |||
3845 | ||||
3846 | std::string EntriesNum = "<?>"; | |||
3847 | if (Expected<size_t> NumOrErr = GetEntriesNum(Sec)) | |||
3848 | EntriesNum = std::to_string(*NumOrErr); | |||
3849 | else | |||
3850 | this->reportUniqueWarning("unable to get the number of relocations in " + | |||
3851 | this->describe(Sec) + ": " + | |||
3852 | toString(NumOrErr.takeError())); | |||
3853 | ||||
3854 | uintX_t Offset = Sec.sh_offset; | |||
3855 | StringRef Name = this->getPrintableSectionName(Sec); | |||
3856 | OS << "\nRelocation section '" << Name << "' at offset 0x" | |||
3857 | << utohexstr(Offset, /*LowerCase=*/true) << " contains " << EntriesNum | |||
3858 | << " entries:\n"; | |||
3859 | printRelocHeaderFields<ELFT>(OS, Sec.sh_type); | |||
3860 | this->printRelocationsHelper(Sec); | |||
3861 | } | |||
3862 | if (!HasRelocSections) | |||
3863 | OS << "\nThere are no relocations in this file.\n"; | |||
3864 | } | |||
3865 | ||||
3866 | // Print the offset of a particular section from anyone of the ranges: | |||
3867 | // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER]. | |||
3868 | // If 'Type' does not fall within any of those ranges, then a string is | |||
3869 | // returned as '<unknown>' followed by the type value. | |||
3870 | static std::string getSectionTypeOffsetString(unsigned Type) { | |||
3871 | if (Type >= SHT_LOOS && Type <= SHT_HIOS) | |||
3872 | return "LOOS+0x" + utohexstr(Type - SHT_LOOS); | |||
3873 | else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC) | |||
3874 | return "LOPROC+0x" + utohexstr(Type - SHT_LOPROC); | |||
3875 | else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER) | |||
3876 | return "LOUSER+0x" + utohexstr(Type - SHT_LOUSER); | |||
3877 | return "0x" + utohexstr(Type) + ": <unknown>"; | |||
3878 | } | |||
3879 | ||||
3880 | static std::string getSectionTypeString(unsigned Machine, unsigned Type) { | |||
3881 | StringRef Name = getELFSectionTypeName(Machine, Type); | |||
3882 | ||||
3883 | // Handle SHT_GNU_* type names. | |||
3884 | if (Name.consume_front("SHT_GNU_")) { | |||
3885 | if (Name == "HASH") | |||
3886 | return "GNU_HASH"; | |||
3887 | // E.g. SHT_GNU_verneed -> VERNEED. | |||
3888 | return Name.upper(); | |||
3889 | } | |||
3890 | ||||
3891 | if (Name == "SHT_SYMTAB_SHNDX") | |||
3892 | return "SYMTAB SECTION INDICES"; | |||
3893 | ||||
3894 | if (Name.consume_front("SHT_")) | |||
3895 | return Name.str(); | |||
3896 | return getSectionTypeOffsetString(Type); | |||
3897 | } | |||
3898 | ||||
3899 | static void printSectionDescription(formatted_raw_ostream &OS, | |||
3900 | unsigned EMachine) { | |||
3901 | OS << "Key to Flags:\n"; | |||
3902 | OS << " W (write), A (alloc), X (execute), M (merge), S (strings), I " | |||
3903 | "(info),\n"; | |||
3904 | OS << " L (link order), O (extra OS processing required), G (group), T " | |||
3905 | "(TLS),\n"; | |||
3906 | OS << " C (compressed), x (unknown), o (OS specific), E (exclude),\n"; | |||
3907 | OS << " R (retain)"; | |||
3908 | ||||
3909 | if (EMachine == EM_X86_64) | |||
3910 | OS << ", l (large)"; | |||
3911 | else if (EMachine == EM_ARM) | |||
3912 | OS << ", y (purecode)"; | |||
3913 | ||||
3914 | OS << ", p (processor specific)\n"; | |||
3915 | } | |||
3916 | ||||
3917 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionHeaders() { | |||
3918 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
3919 | if (Sections.empty()) { | |||
3920 | OS << "\nThere are no sections in this file.\n"; | |||
3921 | Expected<StringRef> SecStrTableOrErr = | |||
3922 | this->Obj.getSectionStringTable(Sections, this->WarningHandler); | |||
3923 | if (!SecStrTableOrErr) | |||
3924 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
3925 | return; | |||
3926 | } | |||
3927 | unsigned Bias = ELFT::Is64Bits ? 0 : 8; | |||
3928 | OS << "There are " << to_string(Sections.size()) | |||
3929 | << " section headers, starting at offset " | |||
3930 | << "0x" << utohexstr(this->Obj.getHeader().e_shoff, /*LowerCase=*/true) << ":\n\n"; | |||
3931 | OS << "Section Headers:\n"; | |||
3932 | Field Fields[11] = { | |||
3933 | {"[Nr]", 2}, {"Name", 7}, {"Type", 25}, | |||
3934 | {"Address", 41}, {"Off", 58 - Bias}, {"Size", 65 - Bias}, | |||
3935 | {"ES", 72 - Bias}, {"Flg", 75 - Bias}, {"Lk", 79 - Bias}, | |||
3936 | {"Inf", 82 - Bias}, {"Al", 86 - Bias}}; | |||
3937 | for (const Field &F : Fields) | |||
3938 | printField(F); | |||
3939 | OS << "\n"; | |||
3940 | ||||
3941 | StringRef SecStrTable; | |||
3942 | if (Expected<StringRef> SecStrTableOrErr = | |||
3943 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
3944 | SecStrTable = *SecStrTableOrErr; | |||
3945 | else | |||
3946 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
3947 | ||||
3948 | size_t SectionIndex = 0; | |||
3949 | for (const Elf_Shdr &Sec : Sections) { | |||
3950 | Fields[0].Str = to_string(SectionIndex); | |||
3951 | if (SecStrTable.empty()) | |||
3952 | Fields[1].Str = "<no-strings>"; | |||
3953 | else | |||
3954 | Fields[1].Str = std::string(unwrapOrError<StringRef>( | |||
3955 | this->FileName, this->Obj.getSectionName(Sec, SecStrTable))); | |||
3956 | Fields[2].Str = | |||
3957 | getSectionTypeString(this->Obj.getHeader().e_machine, Sec.sh_type); | |||
3958 | Fields[3].Str = | |||
3959 | to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8)); | |||
3960 | Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); | |||
3961 | Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6)); | |||
3962 | Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); | |||
3963 | Fields[7].Str = getGNUFlags(this->Obj.getHeader().e_ident[ELF::EI_OSABI], | |||
3964 | this->Obj.getHeader().e_machine, Sec.sh_flags); | |||
3965 | Fields[8].Str = to_string(Sec.sh_link); | |||
3966 | Fields[9].Str = to_string(Sec.sh_info); | |||
3967 | Fields[10].Str = to_string(Sec.sh_addralign); | |||
3968 | ||||
3969 | OS.PadToColumn(Fields[0].Column); | |||
3970 | OS << "[" << right_justify(Fields[0].Str, 2) << "]"; | |||
3971 | for (int i = 1; i < 7; i++) | |||
3972 | printField(Fields[i]); | |||
3973 | OS.PadToColumn(Fields[7].Column); | |||
3974 | OS << right_justify(Fields[7].Str, 3); | |||
3975 | OS.PadToColumn(Fields[8].Column); | |||
3976 | OS << right_justify(Fields[8].Str, 2); | |||
3977 | OS.PadToColumn(Fields[9].Column); | |||
3978 | OS << right_justify(Fields[9].Str, 3); | |||
3979 | OS.PadToColumn(Fields[10].Column); | |||
3980 | OS << right_justify(Fields[10].Str, 2); | |||
3981 | OS << "\n"; | |||
3982 | ++SectionIndex; | |||
3983 | } | |||
3984 | printSectionDescription(OS, this->Obj.getHeader().e_machine); | |||
3985 | } | |||
3986 | ||||
3987 | template <class ELFT> | |||
3988 | void GNUELFDumper<ELFT>::printSymtabMessage(const Elf_Shdr *Symtab, | |||
3989 | size_t Entries, | |||
3990 | bool NonVisibilityBitsUsed) const { | |||
3991 | StringRef Name; | |||
3992 | if (Symtab) | |||
3993 | Name = this->getPrintableSectionName(*Symtab); | |||
3994 | if (!Name.empty()) | |||
3995 | OS << "\nSymbol table '" << Name << "'"; | |||
3996 | else | |||
3997 | OS << "\nSymbol table for image"; | |||
3998 | OS << " contains " << Entries << " entries:\n"; | |||
3999 | ||||
4000 | if (ELFT::Is64Bits) | |||
4001 | OS << " Num: Value Size Type Bind Vis"; | |||
4002 | else | |||
4003 | OS << " Num: Value Size Type Bind Vis"; | |||
4004 | ||||
4005 | if (NonVisibilityBitsUsed) | |||
4006 | OS << " "; | |||
4007 | OS << " Ndx Name\n"; | |||
4008 | } | |||
4009 | ||||
4010 | template <class ELFT> | |||
4011 | std::string | |||
4012 | GNUELFDumper<ELFT>::getSymbolSectionNdx(const Elf_Sym &Symbol, | |||
4013 | unsigned SymIndex, | |||
4014 | DataRegion<Elf_Word> ShndxTable) const { | |||
4015 | unsigned SectionIndex = Symbol.st_shndx; | |||
4016 | switch (SectionIndex) { | |||
4017 | case ELF::SHN_UNDEF: | |||
4018 | return "UND"; | |||
4019 | case ELF::SHN_ABS: | |||
4020 | return "ABS"; | |||
4021 | case ELF::SHN_COMMON: | |||
4022 | return "COM"; | |||
4023 | case ELF::SHN_XINDEX: { | |||
4024 | Expected<uint32_t> IndexOrErr = | |||
4025 | object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex, ShndxTable); | |||
4026 | if (!IndexOrErr) { | |||
4027 | 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", 4029, __extension__ __PRETTY_FUNCTION__)) | |||
4028 | "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", 4029, __extension__ __PRETTY_FUNCTION__)) | |||
4029 | "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", 4029, __extension__ __PRETTY_FUNCTION__)); | |||
4030 | this->reportUniqueWarning(IndexOrErr.takeError()); | |||
4031 | return "RSV[0xffff]"; | |||
4032 | } | |||
4033 | return to_string(format_decimal(*IndexOrErr, 3)); | |||
4034 | } | |||
4035 | default: | |||
4036 | // Find if: | |||
4037 | // Processor specific | |||
4038 | if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) | |||
4039 | return std::string("PRC[0x") + | |||
4040 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
4041 | // OS specific | |||
4042 | if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) | |||
4043 | return std::string("OS[0x") + | |||
4044 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
4045 | // Architecture reserved: | |||
4046 | if (SectionIndex >= ELF::SHN_LORESERVE && | |||
4047 | SectionIndex <= ELF::SHN_HIRESERVE) | |||
4048 | return std::string("RSV[0x") + | |||
4049 | to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; | |||
4050 | // A normal section with an index | |||
4051 | return to_string(format_decimal(SectionIndex, 3)); | |||
4052 | } | |||
4053 | } | |||
4054 | ||||
4055 | template <class ELFT> | |||
4056 | void GNUELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
4057 | DataRegion<Elf_Word> ShndxTable, | |||
4058 | std::optional<StringRef> StrTable, | |||
4059 | bool IsDynamic, | |||
4060 | bool NonVisibilityBitsUsed) const { | |||
4061 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
4062 | Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, | |||
4063 | 31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias}; | |||
4064 | Fields[0].Str = to_string(format_decimal(SymIndex, 6)) + ":"; | |||
4065 | Fields[1].Str = | |||
4066 | to_string(format_hex_no_prefix(Symbol.st_value, ELFT::Is64Bits ? 16 : 8)); | |||
4067 | Fields[2].Str = to_string(format_decimal(Symbol.st_size, 5)); | |||
4068 | ||||
4069 | unsigned char SymbolType = Symbol.getType(); | |||
4070 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
4071 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
4072 | Fields[3].Str = enumToString(SymbolType, ArrayRef(AMDGPUSymbolTypes)); | |||
4073 | else | |||
4074 | Fields[3].Str = enumToString(SymbolType, ArrayRef(ElfSymbolTypes)); | |||
4075 | ||||
4076 | Fields[4].Str = | |||
4077 | enumToString(Symbol.getBinding(), ArrayRef(ElfSymbolBindings)); | |||
4078 | Fields[5].Str = | |||
4079 | enumToString(Symbol.getVisibility(), ArrayRef(ElfSymbolVisibilities)); | |||
4080 | ||||
4081 | if (Symbol.st_other & ~0x3) { | |||
4082 | if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) { | |||
4083 | uint8_t Other = Symbol.st_other & ~0x3; | |||
4084 | if (Other & STO_AARCH64_VARIANT_PCS) { | |||
4085 | Other &= ~STO_AARCH64_VARIANT_PCS; | |||
4086 | Fields[5].Str += " [VARIANT_PCS"; | |||
4087 | if (Other != 0) | |||
4088 | Fields[5].Str.append(" | " + utohexstr(Other, /*LowerCase=*/true)); | |||
4089 | Fields[5].Str.append("]"); | |||
4090 | } | |||
4091 | } else if (this->Obj.getHeader().e_machine == ELF::EM_RISCV) { | |||
4092 | uint8_t Other = Symbol.st_other & ~0x3; | |||
4093 | if (Other & STO_RISCV_VARIANT_CC) { | |||
4094 | Other &= ~STO_RISCV_VARIANT_CC; | |||
4095 | Fields[5].Str += " [VARIANT_CC"; | |||
4096 | if (Other != 0) | |||
4097 | Fields[5].Str.append(" | " + utohexstr(Other, /*LowerCase=*/true)); | |||
4098 | Fields[5].Str.append("]"); | |||
4099 | } | |||
4100 | } else { | |||
4101 | Fields[5].Str += | |||
4102 | " [<other: " + to_string(format_hex(Symbol.st_other, 2)) + ">]"; | |||
4103 | } | |||
4104 | } | |||
4105 | ||||
4106 | Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0; | |||
4107 | Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex, ShndxTable); | |||
4108 | ||||
4109 | Fields[7].Str = this->getFullSymbolName(Symbol, SymIndex, ShndxTable, | |||
4110 | StrTable, IsDynamic); | |||
4111 | for (const Field &Entry : Fields) | |||
4112 | printField(Entry); | |||
4113 | OS << "\n"; | |||
4114 | } | |||
4115 | ||||
4116 | template <class ELFT> | |||
4117 | void GNUELFDumper<ELFT>::printHashedSymbol(const Elf_Sym *Symbol, | |||
4118 | unsigned SymIndex, | |||
4119 | DataRegion<Elf_Word> ShndxTable, | |||
4120 | StringRef StrTable, | |||
4121 | uint32_t Bucket) { | |||
4122 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
4123 | Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias, | |||
4124 | 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias}; | |||
4125 | Fields[0].Str = to_string(format_decimal(SymIndex, 5)); | |||
4126 | Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":"; | |||
4127 | ||||
4128 | Fields[2].Str = to_string( | |||
4129 | format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); | |||
4130 | Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5)); | |||
4131 | ||||
4132 | unsigned char SymbolType = Symbol->getType(); | |||
4133 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
4134 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
4135 | Fields[4].Str = enumToString(SymbolType, ArrayRef(AMDGPUSymbolTypes)); | |||
4136 | else | |||
4137 | Fields[4].Str = enumToString(SymbolType, ArrayRef(ElfSymbolTypes)); | |||
4138 | ||||
4139 | Fields[5].Str = | |||
4140 | enumToString(Symbol->getBinding(), ArrayRef(ElfSymbolBindings)); | |||
4141 | Fields[6].Str = | |||
4142 | enumToString(Symbol->getVisibility(), ArrayRef(ElfSymbolVisibilities)); | |||
4143 | Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable); | |||
4144 | Fields[8].Str = | |||
4145 | this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true); | |||
4146 | ||||
4147 | for (const Field &Entry : Fields) | |||
4148 | printField(Entry); | |||
4149 | OS << "\n"; | |||
4150 | } | |||
4151 | ||||
4152 | template <class ELFT> | |||
4153 | void GNUELFDumper<ELFT>::printSymbols(bool PrintSymbols, | |||
4154 | bool PrintDynamicSymbols) { | |||
4155 | if (!PrintSymbols && !PrintDynamicSymbols) | |||
4156 | return; | |||
4157 | // GNU readelf prints both the .dynsym and .symtab with --symbols. | |||
4158 | this->printSymbolsHelper(true); | |||
4159 | if (PrintSymbols) | |||
4160 | this->printSymbolsHelper(false); | |||
4161 | } | |||
4162 | ||||
4163 | template <class ELFT> | |||
4164 | void GNUELFDumper<ELFT>::printHashTableSymbols(const Elf_Hash &SysVHash) { | |||
4165 | if (this->DynamicStringTable.empty()) | |||
4166 | return; | |||
4167 | ||||
4168 | if (ELFT::Is64Bits) | |||
4169 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4170 | else | |||
4171 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4172 | OS << "\n"; | |||
4173 | ||||
4174 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
4175 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
4176 | if (!FirstSym) { | |||
4177 | this->reportUniqueWarning( | |||
4178 | Twine("unable to print symbols for the .hash table: the " | |||
4179 | "dynamic symbol table ") + | |||
4180 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
4181 | return; | |||
4182 | } | |||
4183 | ||||
4184 | DataRegion<Elf_Word> ShndxTable( | |||
4185 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
4186 | auto Buckets = SysVHash.buckets(); | |||
4187 | auto Chains = SysVHash.chains(); | |||
4188 | for (uint32_t Buc = 0; Buc < SysVHash.nbucket; Buc++) { | |||
4189 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
4190 | continue; | |||
4191 | BitVector Visited(SysVHash.nchain); | |||
4192 | for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash.nchain; Ch = Chains[Ch]) { | |||
4193 | if (Ch == ELF::STN_UNDEF) | |||
4194 | break; | |||
4195 | ||||
4196 | if (Visited[Ch]) { | |||
4197 | this->reportUniqueWarning(".hash section is invalid: bucket " + | |||
4198 | Twine(Ch) + | |||
4199 | ": a cycle was detected in the linked chain"); | |||
4200 | break; | |||
4201 | } | |||
4202 | ||||
4203 | printHashedSymbol(FirstSym + Ch, Ch, ShndxTable, this->DynamicStringTable, | |||
4204 | Buc); | |||
4205 | Visited[Ch] = true; | |||
4206 | } | |||
4207 | } | |||
4208 | } | |||
4209 | ||||
4210 | template <class ELFT> | |||
4211 | void GNUELFDumper<ELFT>::printGnuHashTableSymbols(const Elf_GnuHash &GnuHash) { | |||
4212 | if (this->DynamicStringTable.empty()) | |||
4213 | return; | |||
4214 | ||||
4215 | Elf_Sym_Range DynSyms = this->dynamic_symbols(); | |||
4216 | const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; | |||
4217 | if (!FirstSym) { | |||
4218 | this->reportUniqueWarning( | |||
4219 | Twine("unable to print symbols for the .gnu.hash table: the " | |||
4220 | "dynamic symbol table ") + | |||
4221 | (this->DynSymRegion ? "is empty" : "was not found")); | |||
4222 | return; | |||
4223 | } | |||
4224 | ||||
4225 | auto GetSymbol = [&](uint64_t SymIndex, | |||
4226 | uint64_t SymsTotal) -> const Elf_Sym * { | |||
4227 | if (SymIndex >= SymsTotal) { | |||
4228 | this->reportUniqueWarning( | |||
4229 | "unable to print hashed symbol with index " + Twine(SymIndex) + | |||
4230 | ", which is greater than or equal to the number of dynamic symbols " | |||
4231 | "(" + | |||
4232 | Twine::utohexstr(SymsTotal) + ")"); | |||
4233 | return nullptr; | |||
4234 | } | |||
4235 | return FirstSym + SymIndex; | |||
4236 | }; | |||
4237 | ||||
4238 | Expected<ArrayRef<Elf_Word>> ValuesOrErr = | |||
4239 | getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHash); | |||
4240 | ArrayRef<Elf_Word> Values; | |||
4241 | if (!ValuesOrErr) | |||
4242 | this->reportUniqueWarning("unable to get hash values for the SHT_GNU_HASH " | |||
4243 | "section: " + | |||
4244 | toString(ValuesOrErr.takeError())); | |||
4245 | else | |||
4246 | Values = *ValuesOrErr; | |||
4247 | ||||
4248 | DataRegion<Elf_Word> ShndxTable( | |||
4249 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
4250 | ArrayRef<Elf_Word> Buckets = GnuHash.buckets(); | |||
4251 | for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) { | |||
4252 | if (Buckets[Buc] == ELF::STN_UNDEF) | |||
4253 | continue; | |||
4254 | uint32_t Index = Buckets[Buc]; | |||
4255 | // Print whole chain. | |||
4256 | while (true) { | |||
4257 | uint32_t SymIndex = Index++; | |||
4258 | if (const Elf_Sym *Sym = GetSymbol(SymIndex, DynSyms.size())) | |||
4259 | printHashedSymbol(Sym, SymIndex, ShndxTable, this->DynamicStringTable, | |||
4260 | Buc); | |||
4261 | else | |||
4262 | break; | |||
4263 | ||||
4264 | if (SymIndex < GnuHash.symndx) { | |||
4265 | this->reportUniqueWarning( | |||
4266 | "unable to read the hash value for symbol with index " + | |||
4267 | Twine(SymIndex) + | |||
4268 | ", which is less than the index of the first hashed symbol (" + | |||
4269 | Twine(GnuHash.symndx) + ")"); | |||
4270 | break; | |||
4271 | } | |||
4272 | ||||
4273 | // Chain ends at symbol with stopper bit. | |||
4274 | if ((Values[SymIndex - GnuHash.symndx] & 1) == 1) | |||
4275 | break; | |||
4276 | } | |||
4277 | } | |||
4278 | } | |||
4279 | ||||
4280 | template <class ELFT> void GNUELFDumper<ELFT>::printHashSymbols() { | |||
4281 | if (this->HashTable) { | |||
4282 | OS << "\n Symbol table of .hash for image:\n"; | |||
4283 | if (Error E = checkHashTable<ELFT>(*this, this->HashTable)) | |||
4284 | this->reportUniqueWarning(std::move(E)); | |||
4285 | else | |||
4286 | printHashTableSymbols(*this->HashTable); | |||
4287 | } | |||
4288 | ||||
4289 | // Try printing the .gnu.hash table. | |||
4290 | if (this->GnuHashTable) { | |||
4291 | OS << "\n Symbol table of .gnu.hash for image:\n"; | |||
4292 | if (ELFT::Is64Bits) | |||
4293 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4294 | else | |||
4295 | OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; | |||
4296 | OS << "\n"; | |||
4297 | ||||
4298 | if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable)) | |||
4299 | this->reportUniqueWarning(std::move(E)); | |||
4300 | else | |||
4301 | printGnuHashTableSymbols(*this->GnuHashTable); | |||
4302 | } | |||
4303 | } | |||
4304 | ||||
4305 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionDetails() { | |||
4306 | ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections()); | |||
4307 | if (Sections.empty()) { | |||
4308 | OS << "\nThere are no sections in this file.\n"; | |||
4309 | Expected<StringRef> SecStrTableOrErr = | |||
4310 | this->Obj.getSectionStringTable(Sections, this->WarningHandler); | |||
4311 | if (!SecStrTableOrErr) | |||
4312 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
4313 | return; | |||
4314 | } | |||
4315 | OS << "There are " << to_string(Sections.size()) | |||
4316 | << " section headers, starting at offset " | |||
4317 | << "0x" << utohexstr(this->Obj.getHeader().e_shoff, /*LowerCase=*/true) << ":\n\n"; | |||
4318 | ||||
4319 | OS << "Section Headers:\n"; | |||
4320 | ||||
4321 | auto PrintFields = [&](ArrayRef<Field> V) { | |||
4322 | for (const Field &F : V) | |||
4323 | printField(F); | |||
4324 | OS << "\n"; | |||
4325 | }; | |||
4326 | ||||
4327 | PrintFields({{"[Nr]", 2}, {"Name", 7}}); | |||
4328 | ||||
4329 | constexpr bool Is64 = ELFT::Is64Bits; | |||
4330 | PrintFields({{"Type", 7}, | |||
4331 | {Is64 ? "Address" : "Addr", 23}, | |||
4332 | {"Off", Is64 ? 40 : 32}, | |||
4333 | {"Size", Is64 ? 47 : 39}, | |||
4334 | {"ES", Is64 ? 54 : 46}, | |||
4335 | {"Lk", Is64 ? 59 : 51}, | |||
4336 | {"Inf", Is64 ? 62 : 54}, | |||
4337 | {"Al", Is64 ? 66 : 57}}); | |||
4338 | PrintFields({{"Flags", 7}}); | |||
4339 | ||||
4340 | StringRef SecStrTable; | |||
4341 | if (Expected<StringRef> SecStrTableOrErr = | |||
4342 | this->Obj.getSectionStringTable(Sections, this->WarningHandler)) | |||
4343 | SecStrTable = *SecStrTableOrErr; | |||
4344 | else | |||
4345 | this->reportUniqueWarning(SecStrTableOrErr.takeError()); | |||
4346 | ||||
4347 | size_t SectionIndex = 0; | |||
4348 | const unsigned AddrSize = Is64 ? 16 : 8; | |||
4349 | for (const Elf_Shdr &S : Sections) { | |||
4350 | StringRef Name = "<?>"; | |||
4351 | if (Expected<StringRef> NameOrErr = | |||
4352 | this->Obj.getSectionName(S, SecStrTable)) | |||
4353 | Name = *NameOrErr; | |||
4354 | else | |||
4355 | this->reportUniqueWarning(NameOrErr.takeError()); | |||
4356 | ||||
4357 | OS.PadToColumn(2); | |||
4358 | OS << "[" << right_justify(to_string(SectionIndex), 2) << "]"; | |||
4359 | PrintFields({{Name, 7}}); | |||
4360 | PrintFields( | |||
4361 | {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type), 7}, | |||
4362 | {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 23}, | |||
4363 | {to_string(format_hex_no_prefix(S.sh_offset, 6)), Is64 ? 39 : 32}, | |||
4364 | {to_string(format_hex_no_prefix(S.sh_size, 6)), Is64 ? 47 : 39}, | |||
4365 | {to_string(format_hex_no_prefix(S.sh_entsize, 2)), Is64 ? 54 : 46}, | |||
4366 | {to_string(S.sh_link), Is64 ? 59 : 51}, | |||
4367 | {to_string(S.sh_info), Is64 ? 63 : 55}, | |||
4368 | {to_string(S.sh_addralign), Is64 ? 66 : 58}}); | |||
4369 | ||||
4370 | OS.PadToColumn(7); | |||
4371 | OS << "[" << to_string(format_hex_no_prefix(S.sh_flags, AddrSize)) << "]: "; | |||
4372 | ||||
4373 | DenseMap<unsigned, StringRef> FlagToName = { | |||
4374 | {SHF_WRITE, "WRITE"}, {SHF_ALLOC, "ALLOC"}, | |||
4375 | {SHF_EXECINSTR, "EXEC"}, {SHF_MERGE, "MERGE"}, | |||
4376 | {SHF_STRINGS, "STRINGS"}, {SHF_INFO_LINK, "INFO LINK"}, | |||
4377 | {SHF_LINK_ORDER, "LINK ORDER"}, {SHF_OS_NONCONFORMING, "OS NONCONF"}, | |||
4378 | {SHF_GROUP, "GROUP"}, {SHF_TLS, "TLS"}, | |||
4379 | {SHF_COMPRESSED, "COMPRESSED"}, {SHF_EXCLUDE, "EXCLUDE"}}; | |||
4380 | ||||
4381 | uint64_t Flags = S.sh_flags; | |||
4382 | uint64_t UnknownFlags = 0; | |||
4383 | ListSeparator LS; | |||
4384 | while (Flags) { | |||
4385 | // Take the least significant bit as a flag. | |||
4386 | uint64_t Flag = Flags & -Flags; | |||
4387 | Flags -= Flag; | |||
4388 | ||||
4389 | auto It = FlagToName.find(Flag); | |||
4390 | if (It != FlagToName.end()) | |||
4391 | OS << LS << It->second; | |||
4392 | else | |||
4393 | UnknownFlags |= Flag; | |||
4394 | } | |||
4395 | ||||
4396 | auto PrintUnknownFlags = [&](uint64_t Mask, StringRef Name) { | |||
4397 | uint64_t FlagsToPrint = UnknownFlags & Mask; | |||
4398 | if (!FlagsToPrint) | |||
4399 | return; | |||
4400 | ||||
4401 | OS << LS << Name << " (" | |||
4402 | << to_string(format_hex_no_prefix(FlagsToPrint, AddrSize)) << ")"; | |||
4403 | UnknownFlags &= ~Mask; | |||
4404 | }; | |||
4405 | ||||
4406 | PrintUnknownFlags(SHF_MASKOS, "OS"); | |||
4407 | PrintUnknownFlags(SHF_MASKPROC, "PROC"); | |||
4408 | PrintUnknownFlags(uint64_t(-1), "UNKNOWN"); | |||
4409 | ||||
4410 | OS << "\n"; | |||
4411 | ++SectionIndex; | |||
4412 | ||||
4413 | if (!(S.sh_flags & SHF_COMPRESSED)) | |||
4414 | continue; | |||
4415 | Expected<ArrayRef<uint8_t>> Data = this->Obj.getSectionContents(S); | |||
4416 | if (!Data || Data->size() < sizeof(Elf_Chdr)) { | |||
4417 | consumeError(Data.takeError()); | |||
4418 | reportWarning(createError("SHF_COMPRESSED section '" + Name + | |||
4419 | "' does not have an Elf_Chdr header"), | |||
4420 | this->FileName); | |||
4421 | OS.indent(7); | |||
4422 | OS << "[<corrupt>]"; | |||
4423 | } else { | |||
4424 | OS.indent(7); | |||
4425 | auto *Chdr = reinterpret_cast<const Elf_Chdr *>(Data->data()); | |||
4426 | if (Chdr->ch_type == ELFCOMPRESS_ZLIB) | |||
4427 | OS << "ZLIB"; | |||
4428 | else if (Chdr->ch_type == ELFCOMPRESS_ZSTD) | |||
4429 | OS << "ZSTD"; | |||
4430 | else | |||
4431 | OS << format("[<unknown>: 0x%x]", unsigned(Chdr->ch_type)); | |||
4432 | OS << ", " << format_hex_no_prefix(Chdr->ch_size, ELFT::Is64Bits ? 16 : 8) | |||
4433 | << ", " << Chdr->ch_addralign; | |||
4434 | } | |||
4435 | OS << '\n'; | |||
4436 | } | |||
4437 | } | |||
4438 | ||||
4439 | static inline std::string printPhdrFlags(unsigned Flag) { | |||
4440 | std::string Str; | |||
4441 | Str = (Flag & PF_R) ? "R" : " "; | |||
4442 | Str += (Flag & PF_W) ? "W" : " "; | |||
4443 | Str += (Flag & PF_X) ? "E" : " "; | |||
4444 | return Str; | |||
4445 | } | |||
4446 | ||||
4447 | template <class ELFT> | |||
4448 | static bool checkTLSSections(const typename ELFT::Phdr &Phdr, | |||
4449 | const typename ELFT::Shdr &Sec) { | |||
4450 | if (Sec.sh_flags & ELF::SHF_TLS) { | |||
4451 | // .tbss must only be shown in the PT_TLS segment. | |||
4452 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4453 | return Phdr.p_type == ELF::PT_TLS; | |||
4454 | ||||
4455 | // SHF_TLS sections are only shown in PT_TLS, PT_LOAD or PT_GNU_RELRO | |||
4456 | // segments. | |||
4457 | return (Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || | |||
4458 | (Phdr.p_type == ELF::PT_GNU_RELRO); | |||
4459 | } | |||
4460 | ||||
4461 | // PT_TLS must only have SHF_TLS sections. | |||
4462 | return Phdr.p_type != ELF::PT_TLS; | |||
4463 | } | |||
4464 | ||||
4465 | template <class ELFT> | |||
4466 | static bool checkOffsets(const typename ELFT::Phdr &Phdr, | |||
4467 | const typename ELFT::Shdr &Sec) { | |||
4468 | // SHT_NOBITS sections don't need to have an offset inside the segment. | |||
4469 | if (Sec.sh_type == ELF::SHT_NOBITS) | |||
4470 | return true; | |||
4471 | ||||
4472 | if (Sec.sh_offset < Phdr.p_offset) | |||
4473 | return false; | |||
4474 | ||||
4475 | // Only non-empty sections can be at the end of a segment. | |||
4476 | if (Sec.sh_size == 0) | |||
4477 | return (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz); | |||
4478 | return Sec.sh_offset + Sec.sh_size <= Phdr.p_offset + Phdr.p_filesz; | |||
4479 | } | |||
4480 | ||||
4481 | // Check that an allocatable section belongs to a virtual address | |||
4482 | // space of a segment. | |||
4483 | template <class ELFT> | |||
4484 | static bool checkVMA(const typename ELFT::Phdr &Phdr, | |||
4485 | const typename ELFT::Shdr &Sec) { | |||
4486 | if (!(Sec.sh_flags & ELF::SHF_ALLOC)) | |||
4487 | return true; | |||
4488 | ||||
4489 | if (Sec.sh_addr < Phdr.p_vaddr) | |||
4490 | return false; | |||
4491 | ||||
4492 | bool IsTbss = | |||
4493 | (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); | |||
4494 | // .tbss is special, it only has memory in PT_TLS and has NOBITS properties. | |||
4495 | bool IsTbssInNonTLS = IsTbss && Phdr.p_type != ELF::PT_TLS; | |||
4496 | // Only non-empty sections can be at the end of a segment. | |||
4497 | if (Sec.sh_size == 0 || IsTbssInNonTLS) | |||
4498 | return Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4499 | return Sec.sh_addr + Sec.sh_size <= Phdr.p_vaddr + Phdr.p_memsz; | |||
4500 | } | |||
4501 | ||||
4502 | template <class ELFT> | |||
4503 | static bool checkPTDynamic(const typename ELFT::Phdr &Phdr, | |||
4504 | const typename ELFT::Shdr &Sec) { | |||
4505 | if (Phdr.p_type != ELF::PT_DYNAMIC || Phdr.p_memsz == 0 || Sec.sh_size != 0) | |||
4506 | return true; | |||
4507 | ||||
4508 | // We get here when we have an empty section. Only non-empty sections can be | |||
4509 | // at the start or at the end of PT_DYNAMIC. | |||
4510 | // Is section within the phdr both based on offset and VMA? | |||
4511 | bool CheckOffset = (Sec.sh_type == ELF::SHT_NOBITS) || | |||
4512 | (Sec.sh_offset > Phdr.p_offset && | |||
4513 | Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz); | |||
4514 | bool CheckVA = !(Sec.sh_flags & ELF::SHF_ALLOC) || | |||
4515 | (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz); | |||
4516 | return CheckOffset && CheckVA; | |||
4517 | } | |||
4518 | ||||
4519 | template <class ELFT> | |||
4520 | void GNUELFDumper<ELFT>::printProgramHeaders( | |||
4521 | bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { | |||
4522 | const bool ShouldPrintSectionMapping = (PrintSectionMapping != cl::BOU_FALSE); | |||
4523 | // Exit early if no program header or section mapping details were requested. | |||
4524 | if (!PrintProgramHeaders && !ShouldPrintSectionMapping) | |||
4525 | return; | |||
4526 | ||||
4527 | if (PrintProgramHeaders) { | |||
4528 | const Elf_Ehdr &Header = this->Obj.getHeader(); | |||
4529 | if (Header.e_phnum == 0) { | |||
4530 | OS << "\nThere are no program headers in this file.\n"; | |||
4531 | } else { | |||
4532 | printProgramHeaders(); | |||
4533 | } | |||
4534 | } | |||
4535 | ||||
4536 | if (ShouldPrintSectionMapping) | |||
4537 | printSectionMapping(); | |||
4538 | } | |||
4539 | ||||
4540 | template <class ELFT> void GNUELFDumper<ELFT>::printProgramHeaders() { | |||
4541 | unsigned Bias = ELFT::Is64Bits ? 8 : 0; | |||
4542 | const Elf_Ehdr &Header = this->Obj.getHeader(); | |||
4543 | Field Fields[8] = {2, 17, 26, 37 + Bias, | |||
4544 | 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; | |||
4545 | OS << "\nElf file type is " | |||
4546 | << enumToString(Header.e_type, ArrayRef(ElfObjectFileType)) << "\n" | |||
4547 | << "Entry point " << format_hex(Header.e_entry, 3) << "\n" | |||
4548 | << "There are " << Header.e_phnum << " program headers," | |||
4549 | << " starting at offset " << Header.e_phoff << "\n\n" | |||
4550 | << "Program Headers:\n"; | |||
4551 | if (ELFT::Is64Bits) | |||
4552 | OS << " Type Offset VirtAddr PhysAddr " | |||
4553 | << " FileSiz MemSiz Flg Align\n"; | |||
4554 | else | |||
4555 | OS << " Type Offset VirtAddr PhysAddr FileSiz " | |||
4556 | << "MemSiz Flg Align\n"; | |||
4557 | ||||
4558 | unsigned Width = ELFT::Is64Bits ? 18 : 10; | |||
4559 | unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; | |||
4560 | ||||
4561 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4562 | if (!PhdrsOrErr) { | |||
4563 | this->reportUniqueWarning("unable to dump program headers: " + | |||
4564 | toString(PhdrsOrErr.takeError())); | |||
4565 | return; | |||
4566 | } | |||
4567 | ||||
4568 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4569 | Fields[0].Str = getGNUPtType(Header.e_machine, Phdr.p_type); | |||
4570 | Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8)); | |||
4571 | Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width)); | |||
4572 | Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width)); | |||
4573 | Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth)); | |||
4574 | Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth)); | |||
4575 | Fields[6].Str = printPhdrFlags(Phdr.p_flags); | |||
4576 | Fields[7].Str = to_string(format_hex(Phdr.p_align, 1)); | |||
4577 | for (const Field &F : Fields) | |||
4578 | printField(F); | |||
4579 | if (Phdr.p_type == ELF::PT_INTERP) { | |||
4580 | OS << "\n"; | |||
4581 | auto ReportBadInterp = [&](const Twine &Msg) { | |||
4582 | this->reportUniqueWarning( | |||
4583 | "unable to read program interpreter name at offset 0x" + | |||
4584 | Twine::utohexstr(Phdr.p_offset) + ": " + Msg); | |||
4585 | }; | |||
4586 | ||||
4587 | if (Phdr.p_offset >= this->Obj.getBufSize()) { | |||
4588 | ReportBadInterp("it goes past the end of the file (0x" + | |||
4589 | Twine::utohexstr(this->Obj.getBufSize()) + ")"); | |||
4590 | continue; | |||
4591 | } | |||
4592 | ||||
4593 | const char *Data = | |||
4594 | reinterpret_cast<const char *>(this->Obj.base()) + Phdr.p_offset; | |||
4595 | size_t MaxSize = this->Obj.getBufSize() - Phdr.p_offset; | |||
4596 | size_t Len = strnlen(Data, MaxSize); | |||
4597 | if (Len == MaxSize) { | |||
4598 | ReportBadInterp("it is not null-terminated"); | |||
4599 | continue; | |||
4600 | } | |||
4601 | ||||
4602 | OS << " [Requesting program interpreter: "; | |||
4603 | OS << StringRef(Data, Len) << "]"; | |||
4604 | } | |||
4605 | OS << "\n"; | |||
4606 | } | |||
4607 | } | |||
4608 | ||||
4609 | template <class ELFT> void GNUELFDumper<ELFT>::printSectionMapping() { | |||
4610 | OS << "\n Section to Segment mapping:\n Segment Sections...\n"; | |||
4611 | DenseSet<const Elf_Shdr *> BelongsToSegment; | |||
4612 | int Phnum = 0; | |||
4613 | ||||
4614 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
4615 | if (!PhdrsOrErr) { | |||
4616 | this->reportUniqueWarning( | |||
4617 | "can't read program headers to build section to segment mapping: " + | |||
4618 | toString(PhdrsOrErr.takeError())); | |||
4619 | return; | |||
4620 | } | |||
4621 | ||||
4622 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
4623 | std::string Sections; | |||
4624 | OS << format(" %2.2d ", Phnum++); | |||
4625 | // Check if each section is in a segment and then print mapping. | |||
4626 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4627 | if (Sec.sh_type == ELF::SHT_NULL) | |||
4628 | continue; | |||
4629 | ||||
4630 | // readelf additionally makes sure it does not print zero sized sections | |||
4631 | // at end of segments and for PT_DYNAMIC both start and end of section | |||
4632 | // .tbss must only be shown in PT_TLS section. | |||
4633 | if (checkTLSSections<ELFT>(Phdr, Sec) && checkOffsets<ELFT>(Phdr, Sec) && | |||
4634 | checkVMA<ELFT>(Phdr, Sec) && checkPTDynamic<ELFT>(Phdr, Sec)) { | |||
4635 | Sections += | |||
4636 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4637 | " "; | |||
4638 | BelongsToSegment.insert(&Sec); | |||
4639 | } | |||
4640 | } | |||
4641 | OS << Sections << "\n"; | |||
4642 | OS.flush(); | |||
4643 | } | |||
4644 | ||||
4645 | // Display sections that do not belong to a segment. | |||
4646 | std::string Sections; | |||
4647 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
4648 | if (BelongsToSegment.find(&Sec) == BelongsToSegment.end()) | |||
4649 | Sections += | |||
4650 | unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() + | |||
4651 | ' '; | |||
4652 | } | |||
4653 | if (!Sections.empty()) { | |||
4654 | OS << " None " << Sections << '\n'; | |||
4655 | OS.flush(); | |||
4656 | } | |||
4657 | } | |||
4658 | ||||
4659 | namespace { | |||
4660 | ||||
4661 | template <class ELFT> | |||
4662 | RelSymbol<ELFT> getSymbolForReloc(const ELFDumper<ELFT> &Dumper, | |||
4663 | const Relocation<ELFT> &Reloc) { | |||
4664 | using Elf_Sym = typename ELFT::Sym; | |||
4665 | auto WarnAndReturn = [&](const Elf_Sym *Sym, | |||
4666 | const Twine &Reason) -> RelSymbol<ELFT> { | |||
4667 | Dumper.reportUniqueWarning( | |||
4668 | "unable to get name of the dynamic symbol with index " + | |||
4669 | Twine(Reloc.Symbol) + ": " + Reason); | |||
4670 | return {Sym, "<corrupt>"}; | |||
4671 | }; | |||
4672 | ||||
4673 | ArrayRef<Elf_Sym> Symbols = Dumper.dynamic_symbols(); | |||
4674 | const Elf_Sym *FirstSym = Symbols.begin(); | |||
4675 | if (!FirstSym) | |||
4676 | return WarnAndReturn(nullptr, "no dynamic symbol table found"); | |||
4677 | ||||
4678 | // We might have an object without a section header. In this case the size of | |||
4679 | // Symbols is zero, because there is no way to know the size of the dynamic | |||
4680 | // table. We should allow this case and not print a warning. | |||
4681 | if (!Symbols.empty() && Reloc.Symbol >= Symbols.size()) | |||
4682 | return WarnAndReturn( | |||
4683 | nullptr, | |||
4684 | "index is greater than or equal to the number of dynamic symbols (" + | |||
4685 | Twine(Symbols.size()) + ")"); | |||
4686 | ||||
4687 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
4688 | const uint64_t FileSize = Obj.getBufSize(); | |||
4689 | const uint64_t SymOffset = ((const uint8_t *)FirstSym - Obj.base()) + | |||
4690 | (uint64_t)Reloc.Symbol * sizeof(Elf_Sym); | |||
4691 | if (SymOffset + sizeof(Elf_Sym) > FileSize) | |||
4692 | return WarnAndReturn(nullptr, "symbol at 0x" + Twine::utohexstr(SymOffset) + | |||
4693 | " goes past the end of the file (0x" + | |||
4694 | Twine::utohexstr(FileSize) + ")"); | |||
4695 | ||||
4696 | const Elf_Sym *Sym = FirstSym + Reloc.Symbol; | |||
4697 | Expected<StringRef> ErrOrName = Sym->getName(Dumper.getDynamicStringTable()); | |||
4698 | if (!ErrOrName) | |||
4699 | return WarnAndReturn(Sym, toString(ErrOrName.takeError())); | |||
4700 | ||||
4701 | return {Sym == FirstSym ? nullptr : Sym, maybeDemangle(*ErrOrName)}; | |||
4702 | } | |||
4703 | } // namespace | |||
4704 | ||||
4705 | template <class ELFT> | |||
4706 | static size_t getMaxDynamicTagSize(const ELFFile<ELFT> &Obj, | |||
4707 | typename ELFT::DynRange Tags) { | |||
4708 | size_t Max = 0; | |||
4709 | for (const typename ELFT::Dyn &Dyn : Tags) | |||
4710 | Max = std::max(Max, Obj.getDynamicTagAsString(Dyn.d_tag).size()); | |||
4711 | return Max; | |||
4712 | } | |||
4713 | ||||
4714 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicTable() { | |||
4715 | Elf_Dyn_Range Table = this->dynamic_table(); | |||
4716 | if (Table.empty()) | |||
4717 | return; | |||
4718 | ||||
4719 | OS << "Dynamic section at offset " | |||
4720 | << format_hex(reinterpret_cast<const uint8_t *>(this->DynamicTable.Addr) - | |||
4721 | this->Obj.base(), | |||
4722 | 1) | |||
4723 | << " contains " << Table.size() << " entries:\n"; | |||
4724 | ||||
4725 | // The type name is surrounded with round brackets, hence add 2. | |||
4726 | size_t MaxTagSize = getMaxDynamicTagSize(this->Obj, Table) + 2; | |||
4727 | // The "Name/Value" column should be indented from the "Type" column by N | |||
4728 | // spaces, where N = MaxTagSize - length of "Type" (4) + trailing | |||
4729 | // space (1) = 3. | |||
4730 | OS << " Tag" + std::string(ELFT::Is64Bits ? 16 : 8, ' ') + "Type" | |||
4731 | << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; | |||
4732 | ||||
4733 | std::string ValueFmt = " %-" + std::to_string(MaxTagSize) + "s "; | |||
4734 | for (auto Entry : Table) { | |||
4735 | uintX_t Tag = Entry.getTag(); | |||
4736 | std::string Type = | |||
4737 | std::string("(") + this->Obj.getDynamicTagAsString(Tag) + ")"; | |||
4738 | std::string Value = this->getDynamicEntry(Tag, Entry.getVal()); | |||
4739 | OS << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10) | |||
4740 | << format(ValueFmt.c_str(), Type.c_str()) << Value << "\n"; | |||
4741 | } | |||
4742 | } | |||
4743 | ||||
4744 | template <class ELFT> void GNUELFDumper<ELFT>::printDynamicRelocations() { | |||
4745 | this->printDynamicRelocationsHelper(); | |||
4746 | } | |||
4747 | ||||
4748 | template <class ELFT> | |||
4749 | void ELFDumper<ELFT>::printDynamicReloc(const Relocation<ELFT> &R) { | |||
4750 | printRelRelaReloc(R, getSymbolForReloc(*this, R)); | |||
4751 | } | |||
4752 | ||||
4753 | template <class ELFT> | |||
4754 | void ELFDumper<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) { | |||
4755 | this->forEachRelocationDo( | |||
4756 | Sec, opts::RawRelr, | |||
4757 | [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec, | |||
4758 | const Elf_Shdr *SymTab) { printReloc(R, Ndx, Sec, SymTab); }, | |||
4759 | [&](const Elf_Relr &R) { printRelrReloc(R); }); | |||
4760 | } | |||
4761 | ||||
4762 | template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocationsHelper() { | |||
4763 | const bool IsMips64EL = this->Obj.isMips64EL(); | |||
4764 | if (this->DynRelaRegion.Size > 0) { | |||
4765 | printDynamicRelocHeader(ELF::SHT_RELA, "RELA", this->DynRelaRegion); | |||
4766 | for (const Elf_Rela &Rela : | |||
4767 | this->DynRelaRegion.template getAsArrayRef<Elf_Rela>()) | |||
4768 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4769 | } | |||
4770 | ||||
4771 | if (this->DynRelRegion.Size > 0) { | |||
4772 | printDynamicRelocHeader(ELF::SHT_REL, "REL", this->DynRelRegion); | |||
4773 | for (const Elf_Rel &Rel : | |||
4774 | this->DynRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4775 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4776 | } | |||
4777 | ||||
4778 | if (this->DynRelrRegion.Size > 0) { | |||
4779 | printDynamicRelocHeader(ELF::SHT_REL, "RELR", this->DynRelrRegion); | |||
4780 | Elf_Relr_Range Relrs = | |||
4781 | this->DynRelrRegion.template getAsArrayRef<Elf_Relr>(); | |||
4782 | for (const Elf_Rel &Rel : Obj.decode_relrs(Relrs)) | |||
4783 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4784 | } | |||
4785 | ||||
4786 | if (this->DynPLTRelRegion.Size) { | |||
4787 | if (this->DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { | |||
4788 | printDynamicRelocHeader(ELF::SHT_RELA, "PLT", this->DynPLTRelRegion); | |||
4789 | for (const Elf_Rela &Rela : | |||
4790 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rela>()) | |||
4791 | printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL)); | |||
4792 | } else { | |||
4793 | printDynamicRelocHeader(ELF::SHT_REL, "PLT", this->DynPLTRelRegion); | |||
4794 | for (const Elf_Rel &Rel : | |||
4795 | this->DynPLTRelRegion.template getAsArrayRef<Elf_Rel>()) | |||
4796 | printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL)); | |||
4797 | } | |||
4798 | } | |||
4799 | } | |||
4800 | ||||
4801 | template <class ELFT> | |||
4802 | void GNUELFDumper<ELFT>::printGNUVersionSectionProlog( | |||
4803 | const typename ELFT::Shdr &Sec, const Twine &Label, unsigned EntriesNum) { | |||
4804 | // Don't inline the SecName, because it might report a warning to stderr and | |||
4805 | // corrupt the output. | |||
4806 | StringRef SecName = this->getPrintableSectionName(Sec); | |||
4807 | OS << Label << " section '" << SecName << "' " | |||
4808 | << "contains " << EntriesNum << " entries:\n"; | |||
4809 | ||||
4810 | StringRef LinkedSecName = "<corrupt>"; | |||
4811 | if (Expected<const typename ELFT::Shdr *> LinkedSecOrErr = | |||
4812 | this->Obj.getSection(Sec.sh_link)) | |||
4813 | LinkedSecName = this->getPrintableSectionName(**LinkedSecOrErr); | |||
4814 | else | |||
4815 | this->reportUniqueWarning("invalid section linked to " + | |||
4816 | this->describe(Sec) + ": " + | |||
4817 | toString(LinkedSecOrErr.takeError())); | |||
4818 | ||||
4819 | OS << " Addr: " << format_hex_no_prefix(Sec.sh_addr, 16) | |||
4820 | << " Offset: " << format_hex(Sec.sh_offset, 8) | |||
4821 | << " Link: " << Sec.sh_link << " (" << LinkedSecName << ")\n"; | |||
4822 | } | |||
4823 | ||||
4824 | template <class ELFT> | |||
4825 | void GNUELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) { | |||
4826 | if (!Sec) | |||
4827 | return; | |||
4828 | ||||
4829 | printGNUVersionSectionProlog(*Sec, "Version symbols", | |||
4830 | Sec->sh_size / sizeof(Elf_Versym)); | |||
4831 | Expected<ArrayRef<Elf_Versym>> VerTableOrErr = | |||
4832 | this->getVersionTable(*Sec, /*SymTab=*/nullptr, | |||
4833 | /*StrTab=*/nullptr, /*SymTabSec=*/nullptr); | |||
4834 | if (!VerTableOrErr) { | |||
4835 | this->reportUniqueWarning(VerTableOrErr.takeError()); | |||
4836 | return; | |||
4837 | } | |||
4838 | ||||
4839 | SmallVector<std::optional<VersionEntry>, 0> *VersionMap = nullptr; | |||
4840 | if (Expected<SmallVector<std::optional<VersionEntry>, 0> *> MapOrErr = | |||
4841 | this->getVersionMap()) | |||
4842 | VersionMap = *MapOrErr; | |||
4843 | else | |||
4844 | this->reportUniqueWarning(MapOrErr.takeError()); | |||
4845 | ||||
4846 | ArrayRef<Elf_Versym> VerTable = *VerTableOrErr; | |||
4847 | std::vector<StringRef> Versions; | |||
4848 | for (size_t I = 0, E = VerTable.size(); I < E; ++I) { | |||
4849 | unsigned Ndx = VerTable[I].vs_index; | |||
4850 | if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) { | |||
4851 | Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*"); | |||
4852 | continue; | |||
4853 | } | |||
4854 | ||||
4855 | if (!VersionMap) { | |||
4856 | Versions.emplace_back("<corrupt>"); | |||
4857 | continue; | |||
4858 | } | |||
4859 | ||||
4860 | bool IsDefault; | |||
4861 | Expected<StringRef> NameOrErr = this->Obj.getSymbolVersionByIndex( | |||
4862 | Ndx, IsDefault, *VersionMap, /*IsSymHidden=*/std::nullopt); | |||
4863 | if (!NameOrErr) { | |||
4864 | this->reportUniqueWarning("unable to get a version for entry " + | |||
4865 | Twine(I) + " of " + this->describe(*Sec) + | |||
4866 | ": " + toString(NameOrErr.takeError())); | |||
4867 | Versions.emplace_back("<corrupt>"); | |||
4868 | continue; | |||
4869 | } | |||
4870 | Versions.emplace_back(*NameOrErr); | |||
4871 | } | |||
4872 | ||||
4873 | // readelf prints 4 entries per line. | |||
4874 | uint64_t Entries = VerTable.size(); | |||
4875 | for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) { | |||
4876 | OS << " " << format_hex_no_prefix(VersymRow, 3) << ":"; | |||
4877 | for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) { | |||
4878 | unsigned Ndx = VerTable[VersymRow + I].vs_index; | |||
4879 | OS << format("%4x%c", Ndx & VERSYM_VERSION, | |||
4880 | Ndx & VERSYM_HIDDEN ? 'h' : ' '); | |||
4881 | OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13); | |||
4882 | } | |||
4883 | OS << '\n'; | |||
4884 | } | |||
4885 | OS << '\n'; | |||
4886 | } | |||
4887 | ||||
4888 | static std::string versionFlagToString(unsigned Flags) { | |||
4889 | if (Flags == 0) | |||
4890 | return "none"; | |||
4891 | ||||
4892 | std::string Ret; | |||
4893 | auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) { | |||
4894 | if (!(Flags & Flag)) | |||
4895 | return; | |||
4896 | if (!Ret.empty()) | |||
4897 | Ret += " | "; | |||
4898 | Ret += Name; | |||
4899 | Flags &= ~Flag; | |||
4900 | }; | |||
4901 | ||||
4902 | AddFlag(VER_FLG_BASE, "BASE"); | |||
4903 | AddFlag(VER_FLG_WEAK, "WEAK"); | |||
4904 | AddFlag(VER_FLG_INFO, "INFO"); | |||
4905 | AddFlag(~0, "<unknown>"); | |||
4906 | return Ret; | |||
4907 | } | |||
4908 | ||||
4909 | template <class ELFT> | |||
4910 | void GNUELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) { | |||
4911 | if (!Sec) | |||
4912 | return; | |||
4913 | ||||
4914 | printGNUVersionSectionProlog(*Sec, "Version definition", Sec->sh_info); | |||
4915 | ||||
4916 | Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec); | |||
4917 | if (!V) { | |||
4918 | this->reportUniqueWarning(V.takeError()); | |||
4919 | return; | |||
4920 | } | |||
4921 | ||||
4922 | for (const VerDef &Def : *V) { | |||
4923 | OS << format(" 0x%04x: Rev: %u Flags: %s Index: %u Cnt: %u Name: %s\n", | |||
4924 | Def.Offset, Def.Version, | |||
4925 | versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt, | |||
4926 | Def.Name.data()); | |||
4927 | unsigned I = 0; | |||
4928 | for (const VerdAux &Aux : Def.AuxV) | |||
4929 | OS << format(" 0x%04x: Parent %u: %s\n", Aux.Offset, ++I, | |||
4930 | Aux.Name.data()); | |||
4931 | } | |||
4932 | ||||
4933 | OS << '\n'; | |||
4934 | } | |||
4935 | ||||
4936 | template <class ELFT> | |||
4937 | void GNUELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) { | |||
4938 | if (!Sec) | |||
4939 | return; | |||
4940 | ||||
4941 | unsigned VerneedNum = Sec->sh_info; | |||
4942 | printGNUVersionSectionProlog(*Sec, "Version needs", VerneedNum); | |||
4943 | ||||
4944 | Expected<std::vector<VerNeed>> V = | |||
4945 | this->Obj.getVersionDependencies(*Sec, this->WarningHandler); | |||
4946 | if (!V) { | |||
4947 | this->reportUniqueWarning(V.takeError()); | |||
4948 | return; | |||
4949 | } | |||
4950 | ||||
4951 | for (const VerNeed &VN : *V) { | |||
4952 | OS << format(" 0x%04x: Version: %u File: %s Cnt: %u\n", VN.Offset, | |||
4953 | VN.Version, VN.File.data(), VN.Cnt); | |||
4954 | for (const VernAux &Aux : VN.AuxV) | |||
4955 | OS << format(" 0x%04x: Name: %s Flags: %s Version: %u\n", Aux.Offset, | |||
4956 | Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(), | |||
4957 | Aux.Other); | |||
4958 | } | |||
4959 | OS << '\n'; | |||
4960 | } | |||
4961 | ||||
4962 | template <class ELFT> | |||
4963 | void GNUELFDumper<ELFT>::printHashHistogramStats(size_t NBucket, | |||
4964 | size_t MaxChain, | |||
4965 | size_t TotalSyms, | |||
4966 | ArrayRef<size_t> Count, | |||
4967 | bool IsGnu) const { | |||
4968 | size_t CumulativeNonZero = 0; | |||
4969 | OS << "Histogram for" << (IsGnu ? " `.gnu.hash'" : "") | |||
4970 | << " bucket list length (total of " << NBucket << " buckets)\n" | |||
4971 | << " Length Number % of total Coverage\n"; | |||
4972 | for (size_t I = 0; I < MaxChain; ++I) { | |||
4973 | CumulativeNonZero += Count[I] * I; | |||
4974 | OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], | |||
4975 | (Count[I] * 100.0) / NBucket, | |||
4976 | (CumulativeNonZero * 100.0) / TotalSyms); | |||
4977 | } | |||
4978 | } | |||
4979 | ||||
4980 | template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() { | |||
4981 | OS << "GNUStyle::printCGProfile not implemented\n"; | |||
4982 | } | |||
4983 | ||||
4984 | template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() { | |||
4985 | OS << "GNUStyle::printBBAddrMaps not implemented\n"; | |||
4986 | } | |||
4987 | ||||
4988 | static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) { | |||
4989 | std::vector<uint64_t> Ret; | |||
4990 | const uint8_t *Cur = Data.begin(); | |||
4991 | const uint8_t *End = Data.end(); | |||
4992 | while (Cur != End) { | |||
4993 | unsigned Size; | |||
4994 | const char *Err; | |||
4995 | Ret.push_back(decodeULEB128(Cur, &Size, End, &Err)); | |||
4996 | if (Err) | |||
4997 | return createError(Err); | |||
4998 | Cur += Size; | |||
4999 | } | |||
5000 | return Ret; | |||
5001 | } | |||
5002 | ||||
5003 | template <class ELFT> | |||
5004 | static Expected<std::vector<uint64_t>> | |||
5005 | decodeAddrsigSection(const ELFFile<ELFT> &Obj, const typename ELFT::Shdr &Sec) { | |||
5006 | Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Sec); | |||
5007 | if (!ContentsOrErr) | |||
5008 | return ContentsOrErr.takeError(); | |||
5009 | ||||
5010 | if (Expected<std::vector<uint64_t>> SymsOrErr = | |||
5011 | toULEB128Array(*ContentsOrErr)) | |||
5012 | return *SymsOrErr; | |||
5013 | else | |||
5014 | return createError("unable to decode " + describe(Obj, Sec) + ": " + | |||
5015 | toString(SymsOrErr.takeError())); | |||
5016 | } | |||
5017 | ||||
5018 | template <class ELFT> void GNUELFDumper<ELFT>::printAddrsig() { | |||
5019 | if (!this->DotAddrsigSec) | |||
5020 | return; | |||
5021 | ||||
5022 | Expected<std::vector<uint64_t>> SymsOrErr = | |||
5023 | decodeAddrsigSection(this->Obj, *this->DotAddrsigSec); | |||
5024 | if (!SymsOrErr) { | |||
5025 | this->reportUniqueWarning(SymsOrErr.takeError()); | |||
5026 | return; | |||
5027 | } | |||
5028 | ||||
5029 | StringRef Name = this->getPrintableSectionName(*this->DotAddrsigSec); | |||
5030 | OS << "\nAddress-significant symbols section '" << Name << "'" | |||
5031 | << " contains " << SymsOrErr->size() << " entries:\n"; | |||
5032 | OS << " Num: Name\n"; | |||
5033 | ||||
5034 | Field Fields[2] = {0, 8}; | |||
5035 | size_t SymIndex = 0; | |||
5036 | for (uint64_t Sym : *SymsOrErr) { | |||
5037 | Fields[0].Str = to_string(format_decimal(++SymIndex, 6)) + ":"; | |||
5038 | Fields[1].Str = this->getStaticSymbolName(Sym); | |||
5039 | for (const Field &Entry : Fields) | |||
5040 | printField(Entry); | |||
5041 | OS << "\n"; | |||
5042 | } | |||
5043 | } | |||
5044 | ||||
5045 | template <typename ELFT> | |||
5046 | static std::string getGNUProperty(uint32_t Type, uint32_t DataSize, | |||
5047 | ArrayRef<uint8_t> Data) { | |||
5048 | std::string str; | |||
5049 | raw_string_ostream OS(str); | |||
5050 | uint32_t PrData; | |||
5051 | auto DumpBit = [&](uint32_t Flag, StringRef Name) { | |||
5052 | if (PrData & Flag) { | |||
5053 | PrData &= ~Flag; | |||
5054 | OS << Name; | |||
5055 | if (PrData) | |||
5056 | OS << ", "; | |||
5057 | } | |||
5058 | }; | |||
5059 | ||||
5060 | switch (Type) { | |||
5061 | default: | |||
5062 | OS << format("<application-specific type 0x%x>", Type); | |||
5063 | return OS.str(); | |||
5064 | case GNU_PROPERTY_STACK_SIZE: { | |||
5065 | OS << "stack size: "; | |||
5066 | if (DataSize == sizeof(typename ELFT::uint)) | |||
5067 | OS << formatv("{0:x}", | |||
5068 | (uint64_t)(*(const typename ELFT::Addr *)Data.data())); | |||
5069 | else | |||
5070 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5071 | return OS.str(); | |||
5072 | } | |||
5073 | case GNU_PROPERTY_NO_COPY_ON_PROTECTED: | |||
5074 | OS << "no copy on protected"; | |||
5075 | if (DataSize) | |||
5076 | OS << format(" <corrupt length: 0x%x>", DataSize); | |||
5077 | return OS.str(); | |||
5078 | case GNU_PROPERTY_AARCH64_FEATURE_1_AND: | |||
5079 | case GNU_PROPERTY_X86_FEATURE_1_AND: | |||
5080 | OS << ((Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) ? "aarch64 feature: " | |||
5081 | : "x86 feature: "); | |||
5082 | if (DataSize != 4) { | |||
5083 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5084 | return OS.str(); | |||
5085 | } | |||
5086 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
5087 | if (PrData == 0) { | |||
5088 | OS << "<None>"; | |||
5089 | return OS.str(); | |||
5090 | } | |||
5091 | if (Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) { | |||
5092 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_BTI, "BTI"); | |||
5093 | DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_PAC, "PAC"); | |||
5094 | } else { | |||
5095 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_IBT, "IBT"); | |||
5096 | DumpBit(GNU_PROPERTY_X86_FEATURE_1_SHSTK, "SHSTK"); | |||
5097 | } | |||
5098 | if (PrData) | |||
5099 | OS << format("<unknown flags: 0x%x>", PrData); | |||
5100 | return OS.str(); | |||
5101 | case GNU_PROPERTY_X86_FEATURE_2_NEEDED: | |||
5102 | case GNU_PROPERTY_X86_FEATURE_2_USED: | |||
5103 | OS << "x86 feature " | |||
5104 | << (Type == GNU_PROPERTY_X86_FEATURE_2_NEEDED ? "needed: " : "used: "); | |||
5105 | if (DataSize != 4) { | |||
5106 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5107 | return OS.str(); | |||
5108 | } | |||
5109 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
5110 | if (PrData == 0) { | |||
5111 | OS << "<None>"; | |||
5112 | return OS.str(); | |||
5113 | } | |||
5114 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X86, "x86"); | |||
5115 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_X87, "x87"); | |||
5116 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_MMX, "MMX"); | |||
5117 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XMM, "XMM"); | |||
5118 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_YMM, "YMM"); | |||
5119 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_ZMM, "ZMM"); | |||
5120 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_FXSR, "FXSR"); | |||
5121 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVE, "XSAVE"); | |||
5122 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT, "XSAVEOPT"); | |||
5123 | DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEC, "XSAVEC"); | |||
5124 | if (PrData) | |||
5125 | OS << format("<unknown flags: 0x%x>", PrData); | |||
5126 | return OS.str(); | |||
5127 | case GNU_PROPERTY_X86_ISA_1_NEEDED: | |||
5128 | case GNU_PROPERTY_X86_ISA_1_USED: | |||
5129 | OS << "x86 ISA " | |||
5130 | << (Type == GNU_PROPERTY_X86_ISA_1_NEEDED ? "needed: " : "used: "); | |||
5131 | if (DataSize != 4) { | |||
5132 | OS << format("<corrupt length: 0x%x>", DataSize); | |||
5133 | return OS.str(); | |||
5134 | } | |||
5135 | PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); | |||
5136 | if (PrData == 0) { | |||
5137 | OS << "<None>"; | |||
5138 | return OS.str(); | |||
5139 | } | |||
5140 | DumpBit(GNU_PROPERTY_X86_ISA_1_BASELINE, "x86-64-baseline"); | |||
5141 | DumpBit(GNU_PROPERTY_X86_ISA_1_V2, "x86-64-v2"); | |||
5142 | DumpBit(GNU_PROPERTY_X86_ISA_1_V3, "x86-64-v3"); | |||
5143 | DumpBit(GNU_PROPERTY_X86_ISA_1_V4, "x86-64-v4"); | |||
5144 | if (PrData) | |||
5145 | OS << format("<unknown flags: 0x%x>", PrData); | |||
5146 | return OS.str(); | |||
5147 | } | |||
5148 | } | |||
5149 | ||||
5150 | template <typename ELFT> | |||
5151 | static SmallVector<std::string, 4> getGNUPropertyList(ArrayRef<uint8_t> Arr) { | |||
5152 | using Elf_Word = typename ELFT::Word; | |||
5153 | ||||
5154 | SmallVector<std::string, 4> Properties; | |||
5155 | while (Arr.size() >= 8) { | |||
5156 | uint32_t Type = *reinterpret_cast<const Elf_Word *>(Arr.data()); | |||
5157 | uint32_t DataSize = *reinterpret_cast<const Elf_Word *>(Arr.data() + 4); | |||
5158 | Arr = Arr.drop_front(8); | |||
5159 | ||||
5160 | // Take padding size into account if present. | |||
5161 | uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint)); | |||
5162 | std::string str; | |||
5163 | raw_string_ostream OS(str); | |||
5164 | if (Arr.size() < PaddedSize) { | |||
5165 | OS << format("<corrupt type (0x%x) datasz: 0x%x>", Type, DataSize); | |||
5166 | Properties.push_back(OS.str()); | |||
5167 | break; | |||
5168 | } | |||
5169 | Properties.push_back( | |||
5170 | getGNUProperty<ELFT>(Type, DataSize, Arr.take_front(PaddedSize))); | |||
5171 | Arr = Arr.drop_front(PaddedSize); | |||
5172 | } | |||
5173 | ||||
5174 | if (!Arr.empty()) | |||
5175 | Properties.push_back("<corrupted GNU_PROPERTY_TYPE_0>"); | |||
5176 | ||||
5177 | return Properties; | |||
5178 | } | |||
5179 | ||||
5180 | struct GNUAbiTag { | |||
5181 | std::string OSName; | |||
5182 | std::string ABI; | |||
5183 | bool IsValid; | |||
5184 | }; | |||
5185 | ||||
5186 | template <typename ELFT> static GNUAbiTag getGNUAbiTag(ArrayRef<uint8_t> Desc) { | |||
5187 | typedef typename ELFT::Word Elf_Word; | |||
5188 | ||||
5189 | ArrayRef<Elf_Word> Words(reinterpret_cast<const Elf_Word *>(Desc.begin()), | |||
5190 | reinterpret_cast<const Elf_Word *>(Desc.end())); | |||
5191 | ||||
5192 | if (Words.size() < 4) | |||
5193 | return {"", "", /*IsValid=*/false}; | |||
5194 | ||||
5195 | static const char *OSNames[] = { | |||
5196 | "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl", | |||
5197 | }; | |||
5198 | StringRef OSName = "Unknown"; | |||
5199 | if (Words[0] < std::size(OSNames)) | |||
5200 | OSName = OSNames[Words[0]]; | |||
5201 | uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3]; | |||
5202 | std::string str; | |||
5203 | raw_string_ostream ABI(str); | |||
5204 | ABI << Major << "." << Minor << "." << Patch; | |||
5205 | return {std::string(OSName), ABI.str(), /*IsValid=*/true}; | |||
5206 | } | |||
5207 | ||||
5208 | static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) { | |||
5209 | std::string str; | |||
5210 | raw_string_ostream OS(str); | |||
5211 | for (uint8_t B : Desc) | |||
5212 | OS << format_hex_no_prefix(B, 2); | |||
5213 | return OS.str(); | |||
5214 | } | |||
5215 | ||||
5216 | static StringRef getDescAsStringRef(ArrayRef<uint8_t> Desc) { | |||
5217 | return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5218 | } | |||
5219 | ||||
5220 | template <typename ELFT> | |||
5221 | static bool printGNUNote(raw_ostream &OS, uint32_t NoteType, | |||
5222 | ArrayRef<uint8_t> Desc) { | |||
5223 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5224 | switch (NoteType) { | |||
5225 | default: | |||
5226 | return false; | |||
5227 | case ELF::NT_GNU_ABI_TAG: { | |||
5228 | const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); | |||
5229 | if (!AbiTag.IsValid) | |||
5230 | OS << " <corrupt GNU_ABI_TAG>"; | |||
5231 | else | |||
5232 | OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI; | |||
5233 | break; | |||
5234 | } | |||
5235 | case ELF::NT_GNU_BUILD_ID: { | |||
5236 | OS << " Build ID: " << getGNUBuildId(Desc); | |||
5237 | break; | |||
5238 | } | |||
5239 | case ELF::NT_GNU_GOLD_VERSION: | |||
5240 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5241 | break; | |||
5242 | case ELF::NT_GNU_PROPERTY_TYPE_0: | |||
5243 | OS << " Properties:"; | |||
5244 | for (const std::string &Property : getGNUPropertyList<ELFT>(Desc)) | |||
5245 | OS << " " << Property << "\n"; | |||
5246 | break; | |||
5247 | } | |||
5248 | OS << '\n'; | |||
5249 | return true; | |||
5250 | } | |||
5251 | ||||
5252 | using AndroidNoteProperties = std::vector<std::pair<StringRef, std::string>>; | |||
5253 | static AndroidNoteProperties getAndroidNoteProperties(uint32_t NoteType, | |||
5254 | ArrayRef<uint8_t> Desc) { | |||
5255 | AndroidNoteProperties Props; | |||
5256 | switch (NoteType) { | |||
5257 | case ELF::NT_ANDROID_TYPE_MEMTAG: | |||
5258 | if (Desc.empty()) { | |||
5259 | Props.emplace_back("Invalid .note.android.memtag", ""); | |||
5260 | return Props; | |||
5261 | } | |||
5262 | ||||
5263 | switch (Desc[0] & NT_MEMTAG_LEVEL_MASK) { | |||
5264 | case NT_MEMTAG_LEVEL_NONE: | |||
5265 | Props.emplace_back("Tagging Mode", "NONE"); | |||
5266 | break; | |||
5267 | case NT_MEMTAG_LEVEL_ASYNC: | |||
5268 | Props.emplace_back("Tagging Mode", "ASYNC"); | |||
5269 | break; | |||
5270 | case NT_MEMTAG_LEVEL_SYNC: | |||
5271 | Props.emplace_back("Tagging Mode", "SYNC"); | |||
5272 | break; | |||
5273 | default: | |||
5274 | Props.emplace_back( | |||
5275 | "Tagging Mode", | |||
5276 | ("Unknown (" + Twine::utohexstr(Desc[0] & NT_MEMTAG_LEVEL_MASK) + ")") | |||
5277 | .str()); | |||
5278 | break; | |||
5279 | } | |||
5280 | Props.emplace_back("Heap", | |||
5281 | (Desc[0] & NT_MEMTAG_HEAP) ? "Enabled" : "Disabled"); | |||
5282 | Props.emplace_back("Stack", | |||
5283 | (Desc[0] & NT_MEMTAG_STACK) ? "Enabled" : "Disabled"); | |||
5284 | break; | |||
5285 | default: | |||
5286 | return Props; | |||
5287 | } | |||
5288 | return Props; | |||
5289 | } | |||
5290 | ||||
5291 | static bool printAndroidNote(raw_ostream &OS, uint32_t NoteType, | |||
5292 | ArrayRef<uint8_t> Desc) { | |||
5293 | // Return true if we were able to pretty-print the note, false otherwise. | |||
5294 | AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc); | |||
5295 | if (Props.empty()) | |||
5296 | return false; | |||
5297 | for (const auto &KV : Props) | |||
5298 | OS << " " << KV.first << ": " << KV.second << '\n'; | |||
5299 | return true; | |||
5300 | } | |||
5301 | ||||
5302 | template <class ELFT> | |||
5303 | void GNUELFDumper<ELFT>::printMemtag( | |||
5304 | const ArrayRef<std::pair<std::string, std::string>> DynamicEntries, | |||
5305 | const ArrayRef<uint8_t> AndroidNoteDesc, | |||
5306 | const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) { | |||
5307 | OS << "Memtag Dynamic Entries:\n"; | |||
5308 | if (DynamicEntries.empty()) | |||
5309 | OS << " < none found >\n"; | |||
5310 | for (const auto &DynamicEntryKV : DynamicEntries) | |||
5311 | OS << " " << DynamicEntryKV.first << ": " << DynamicEntryKV.second | |||
5312 | << "\n"; | |||
5313 | ||||
5314 | if (!AndroidNoteDesc.empty()) { | |||
5315 | OS << "Memtag Android Note:\n"; | |||
5316 | printAndroidNote(OS, ELF::NT_ANDROID_TYPE_MEMTAG, AndroidNoteDesc); | |||
5317 | } | |||
5318 | ||||
5319 | if (Descriptors.empty()) | |||
5320 | return; | |||
5321 | ||||
5322 | OS << "Memtag Global Descriptors:\n"; | |||
5323 | for (const auto &[Addr, BytesToTag] : Descriptors) { | |||
5324 | OS << " 0x" << utohexstr(Addr, /*LowerCase=*/true) << ": 0x" | |||
5325 | << utohexstr(BytesToTag, /*LowerCase=*/true) << "\n"; | |||
5326 | } | |||
5327 | } | |||
5328 | ||||
5329 | template <typename ELFT> | |||
5330 | static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType, | |||
5331 | ArrayRef<uint8_t> Desc) { | |||
5332 | switch (NoteType) { | |||
5333 | default: | |||
5334 | return false; | |||
5335 | case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION: | |||
5336 | OS << " Version: " << getDescAsStringRef(Desc); | |||
5337 | break; | |||
5338 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER: | |||
5339 | OS << " Producer: " << getDescAsStringRef(Desc); | |||
5340 | break; | |||
5341 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION: | |||
5342 | OS << " Producer version: " << getDescAsStringRef(Desc); | |||
5343 | break; | |||
5344 | } | |||
5345 | OS << '\n'; | |||
5346 | return true; | |||
5347 | } | |||
5348 | ||||
5349 | const EnumEntry<unsigned> FreeBSDFeatureCtlFlags[] = { | |||
5350 | {"ASLR_DISABLE", NT_FREEBSD_FCTL_ASLR_DISABLE}, | |||
5351 | {"PROTMAX_DISABLE", NT_FREEBSD_FCTL_PROTMAX_DISABLE}, | |||
5352 | {"STKGAP_DISABLE", NT_FREEBSD_FCTL_STKGAP_DISABLE}, | |||
5353 | {"WXNEEDED", NT_FREEBSD_FCTL_WXNEEDED}, | |||
5354 | {"LA48", NT_FREEBSD_FCTL_LA48}, | |||
5355 | {"ASG_DISABLE", NT_FREEBSD_FCTL_ASG_DISABLE}, | |||
5356 | }; | |||
5357 | ||||
5358 | struct FreeBSDNote { | |||
5359 | std::string Type; | |||
5360 | std::string Value; | |||
5361 | }; | |||
5362 | ||||
5363 | template <typename ELFT> | |||
5364 | static std::optional<FreeBSDNote> | |||
5365 | getFreeBSDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc, bool IsCore) { | |||
5366 | if (IsCore) | |||
5367 | return std::nullopt; // No pretty-printing yet. | |||
5368 | switch (NoteType) { | |||
5369 | case ELF::NT_FREEBSD_ABI_TAG: | |||
5370 | if (Desc.size() != 4) | |||
5371 | return std::nullopt; | |||
5372 | return FreeBSDNote{ | |||
5373 | "ABI tag", | |||
5374 | utostr(support::endian::read32<ELFT::TargetEndianness>(Desc.data()))}; | |||
5375 | case ELF::NT_FREEBSD_ARCH_TAG: | |||
5376 | return FreeBSDNote{"Arch tag", toStringRef(Desc).str()}; | |||
5377 | case ELF::NT_FREEBSD_FEATURE_CTL: { | |||
5378 | if (Desc.size() != 4) | |||
5379 | return std::nullopt; | |||
5380 | unsigned Value = | |||
5381 | support::endian::read32<ELFT::TargetEndianness>(Desc.data()); | |||
5382 | std::string FlagsStr; | |||
5383 | raw_string_ostream OS(FlagsStr); | |||
5384 | printFlags(Value, ArrayRef(FreeBSDFeatureCtlFlags), OS); | |||
5385 | if (OS.str().empty()) | |||
5386 | OS << "0x" << utohexstr(Value); | |||
5387 | else | |||
5388 | OS << "(0x" << utohexstr(Value) << ")"; | |||
5389 | return FreeBSDNote{"Feature flags", OS.str()}; | |||
5390 | } | |||
5391 | default: | |||
5392 | return std::nullopt; | |||
5393 | } | |||
5394 | } | |||
5395 | ||||
5396 | struct AMDNote { | |||
5397 | std::string Type; | |||
5398 | std::string Value; | |||
5399 | }; | |||
5400 | ||||
5401 | template <typename ELFT> | |||
5402 | static AMDNote getAMDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5403 | switch (NoteType) { | |||
5404 | default: | |||
5405 | return {"", ""}; | |||
5406 | case ELF::NT_AMD_HSA_CODE_OBJECT_VERSION: { | |||
5407 | struct CodeObjectVersion { | |||
5408 | uint32_t MajorVersion; | |||
5409 | uint32_t MinorVersion; | |||
5410 | }; | |||
5411 | if (Desc.size() != sizeof(CodeObjectVersion)) | |||
5412 | return {"AMD HSA Code Object Version", | |||
5413 | "Invalid AMD HSA Code Object Version"}; | |||
5414 | std::string VersionString; | |||
5415 | raw_string_ostream StrOS(VersionString); | |||
5416 | auto Version = reinterpret_cast<const CodeObjectVersion *>(Desc.data()); | |||
5417 | StrOS << "[Major: " << Version->MajorVersion | |||
5418 | << ", Minor: " << Version->MinorVersion << "]"; | |||
5419 | return {"AMD HSA Code Object Version", VersionString}; | |||
5420 | } | |||
5421 | case ELF::NT_AMD_HSA_HSAIL: { | |||
5422 | struct HSAILProperties { | |||
5423 | uint32_t HSAILMajorVersion; | |||
5424 | uint32_t HSAILMinorVersion; | |||
5425 | uint8_t Profile; | |||
5426 | uint8_t MachineModel; | |||
5427 | uint8_t DefaultFloatRound; | |||
5428 | }; | |||
5429 | if (Desc.size() != sizeof(HSAILProperties)) | |||
5430 | return {"AMD HSA HSAIL Properties", "Invalid AMD HSA HSAIL Properties"}; | |||
5431 | auto Properties = reinterpret_cast<const HSAILProperties *>(Desc.data()); | |||
5432 | std::string HSAILPropetiesString; | |||
5433 | raw_string_ostream StrOS(HSAILPropetiesString); | |||
5434 | StrOS << "[HSAIL Major: " << Properties->HSAILMajorVersion | |||
5435 | << ", HSAIL Minor: " << Properties->HSAILMinorVersion | |||
5436 | << ", Profile: " << uint32_t(Properties->Profile) | |||
5437 | << ", Machine Model: " << uint32_t(Properties->MachineModel) | |||
5438 | << ", Default Float Round: " | |||
5439 | << uint32_t(Properties->DefaultFloatRound) << "]"; | |||
5440 | return {"AMD HSA HSAIL Properties", HSAILPropetiesString}; | |||
5441 | } | |||
5442 | case ELF::NT_AMD_HSA_ISA_VERSION: { | |||
5443 | struct IsaVersion { | |||
5444 | uint16_t VendorNameSize; | |||
5445 | uint16_t ArchitectureNameSize; | |||
5446 | uint32_t Major; | |||
5447 | uint32_t Minor; | |||
5448 | uint32_t Stepping; | |||
5449 | }; | |||
5450 | if (Desc.size() < sizeof(IsaVersion)) | |||
5451 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5452 | auto Isa = reinterpret_cast<const IsaVersion *>(Desc.data()); | |||
5453 | if (Desc.size() < sizeof(IsaVersion) + | |||
5454 | Isa->VendorNameSize + Isa->ArchitectureNameSize || | |||
5455 | Isa->VendorNameSize == 0 || Isa->ArchitectureNameSize == 0) | |||
5456 | return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"}; | |||
5457 | std::string IsaString; | |||
5458 | raw_string_ostream StrOS(IsaString); | |||
5459 | StrOS << "[Vendor: " | |||
5460 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion), Isa->VendorNameSize - 1) | |||
5461 | << ", Architecture: " | |||
5462 | << StringRef((const char*)Desc.data() + sizeof(IsaVersion) + Isa->VendorNameSize, | |||
5463 | Isa->ArchitectureNameSize - 1) | |||
5464 | << ", Major: " << Isa->Major << ", Minor: " << Isa->Minor | |||
5465 | << ", Stepping: " << Isa->Stepping << "]"; | |||
5466 | return {"AMD HSA ISA Version", IsaString}; | |||
5467 | } | |||
5468 | case ELF::NT_AMD_HSA_METADATA: { | |||
5469 | if (Desc.size() == 0) | |||
5470 | return {"AMD HSA Metadata", ""}; | |||
5471 | return { | |||
5472 | "AMD HSA Metadata", | |||
5473 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size() - 1)}; | |||
5474 | } | |||
5475 | case ELF::NT_AMD_HSA_ISA_NAME: { | |||
5476 | if (Desc.size() == 0) | |||
5477 | return {"AMD HSA ISA Name", ""}; | |||
5478 | return { | |||
5479 | "AMD HSA ISA Name", | |||
5480 | std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())}; | |||
5481 | } | |||
5482 | case ELF::NT_AMD_PAL_METADATA: { | |||
5483 | struct PALMetadata { | |||
5484 | uint32_t Key; | |||
5485 | uint32_t Value; | |||
5486 | }; | |||
5487 | if (Desc.size() % sizeof(PALMetadata) != 0) | |||
5488 | return {"AMD PAL Metadata", "Invalid AMD PAL Metadata"}; | |||
5489 | auto Isa = reinterpret_cast<const PALMetadata *>(Desc.data()); | |||
5490 | std::string MetadataString; | |||
5491 | raw_string_ostream StrOS(MetadataString); | |||
5492 | for (size_t I = 0, E = Desc.size() / sizeof(PALMetadata); I < E; ++I) { | |||
5493 | StrOS << "[" << Isa[I].Key << ": " << Isa[I].Value << "]"; | |||
5494 | } | |||
5495 | return {"AMD PAL Metadata", MetadataString}; | |||
5496 | } | |||
5497 | } | |||
5498 | } | |||
5499 | ||||
5500 | struct AMDGPUNote { | |||
5501 | std::string Type; | |||
5502 | std::string Value; | |||
5503 | }; | |||
5504 | ||||
5505 | template <typename ELFT> | |||
5506 | static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { | |||
5507 | switch (NoteType) { | |||
5508 | default: | |||
5509 | return {"", ""}; | |||
5510 | case ELF::NT_AMDGPU_METADATA: { | |||
5511 | StringRef MsgPackString = | |||
5512 | StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); | |||
5513 | msgpack::Document MsgPackDoc; | |||
5514 | if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false)) | |||
5515 | return {"", ""}; | |||
5516 | ||||
5517 | std::string MetadataString; | |||
5518 | ||||
5519 | // FIXME: Metadata Verifier only works with AMDHSA. | |||
5520 | // This is an ugly workaround to avoid the verifier for other MD | |||
5521 | // formats (e.g. amdpal) | |||
5522 | if (MsgPackString.find("amdhsa.") != StringRef::npos) { | |||
5523 | AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true); | |||
5524 | if (!Verifier.verify(MsgPackDoc.getRoot())) | |||
5525 | MetadataString = "Invalid AMDGPU Metadata\n"; | |||
5526 | } | |||
5527 | ||||
5528 | raw_string_ostream StrOS(MetadataString); | |||
5529 | if (MsgPackDoc.getRoot().isScalar()) { | |||
5530 | // TODO: passing a scalar root to toYAML() asserts: | |||
5531 | // (PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && | |||
5532 | // "plain scalar documents are not supported") | |||
5533 | // To avoid this crash we print the raw data instead. | |||
5534 | return {"", ""}; | |||
5535 | } | |||
5536 | MsgPackDoc.toYAML(StrOS); | |||
5537 | return {"AMDGPU Metadata", StrOS.str()}; | |||
5538 | } | |||
5539 | } | |||
5540 | } | |||
5541 | ||||
5542 | struct CoreFileMapping { | |||
5543 | uint64_t Start, End, Offset; | |||
5544 | StringRef Filename; | |||
5545 | }; | |||
5546 | ||||
5547 | struct CoreNote { | |||
5548 | uint64_t PageSize; | |||
5549 | std::vector<CoreFileMapping> Mappings; | |||
5550 | }; | |||
5551 | ||||
5552 | static Expected<CoreNote> readCoreNote(DataExtractor Desc) { | |||
5553 | // Expected format of the NT_FILE note description: | |||
5554 | // 1. # of file mappings (call it N) | |||
5555 | // 2. Page size | |||
5556 | // 3. N (start, end, offset) triples | |||
5557 | // 4. N packed filenames (null delimited) | |||
5558 | // Each field is an Elf_Addr, except for filenames which are char* strings. | |||
5559 | ||||
5560 | CoreNote Ret; | |||
5561 | const int Bytes = Desc.getAddressSize(); | |||
5562 | ||||
5563 | if (!Desc.isValidOffsetForAddress(2)) | |||
5564 | return createError("the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5565 | " is too short, expected at least 0x" + | |||
5566 | Twine::utohexstr(Bytes * 2)); | |||
5567 | if (Desc.getData().back() != 0) | |||
5568 | return createError("the note is not NUL terminated"); | |||
5569 | ||||
5570 | uint64_t DescOffset = 0; | |||
5571 | uint64_t FileCount = Desc.getAddress(&DescOffset); | |||
5572 | Ret.PageSize = Desc.getAddress(&DescOffset); | |||
5573 | ||||
5574 | if (!Desc.isValidOffsetForAddress(3 * FileCount * Bytes)) | |||
5575 | return createError("unable to read file mappings (found " + | |||
5576 | Twine(FileCount) + "): the note of size 0x" + | |||
5577 | Twine::utohexstr(Desc.size()) + " is too short"); | |||
5578 | ||||
5579 | uint64_t FilenamesOffset = 0; | |||
5580 | DataExtractor Filenames( | |||
5581 | Desc.getData().drop_front(DescOffset + 3 * FileCount * Bytes), | |||
5582 | Desc.isLittleEndian(), Desc.getAddressSize()); | |||
5583 | ||||
5584 | Ret.Mappings.resize(FileCount); | |||
5585 | size_t I = 0; | |||
5586 | for (CoreFileMapping &Mapping : Ret.Mappings) { | |||
5587 | ++I; | |||
5588 | if (!Filenames.isValidOffsetForDataOfSize(FilenamesOffset, 1)) | |||
5589 | return createError( | |||
5590 | "unable to read the file name for the mapping with index " + | |||
5591 | Twine(I) + ": the note of size 0x" + Twine::utohexstr(Desc.size()) + | |||
5592 | " is truncated"); | |||
5593 | Mapping.Start = Desc.getAddress(&DescOffset); | |||
5594 | Mapping.End = Desc.getAddress(&DescOffset); | |||
5595 | Mapping.Offset = Desc.getAddress(&DescOffset); | |||
5596 | Mapping.Filename = Filenames.getCStrRef(&FilenamesOffset); | |||
5597 | } | |||
5598 | ||||
5599 | return Ret; | |||
5600 | } | |||
5601 | ||||
5602 | template <typename ELFT> | |||
5603 | static void printCoreNote(raw_ostream &OS, const CoreNote &Note) { | |||
5604 | // Length of "0x<address>" string. | |||
5605 | const int FieldWidth = ELFT::Is64Bits ? 18 : 10; | |||
5606 | ||||
5607 | OS << " Page size: " << format_decimal(Note.PageSize, 0) << '\n'; | |||
5608 | OS << " " << right_justify("Start", FieldWidth) << " " | |||
5609 | << right_justify("End", FieldWidth) << " " | |||
5610 | << right_justify("Page Offset", FieldWidth) << '\n'; | |||
5611 | for (const CoreFileMapping &Mapping : Note.Mappings) { | |||
5612 | OS << " " << format_hex(Mapping.Start, FieldWidth) << " " | |||
5613 | << format_hex(Mapping.End, FieldWidth) << " " | |||
5614 | << format_hex(Mapping.Offset, FieldWidth) << "\n " | |||
5615 | << Mapping.Filename << '\n'; | |||
5616 | } | |||
5617 | } | |||
5618 | ||||
5619 | const NoteType GenericNoteTypes[] = { | |||
5620 | {ELF::NT_VERSION, "NT_VERSION (version)"}, | |||
5621 | {ELF::NT_ARCH, "NT_ARCH (architecture)"}, | |||
5622 | {ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN, "OPEN"}, | |||
5623 | {ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC, "func"}, | |||
5624 | }; | |||
5625 | ||||
5626 | const NoteType GNUNoteTypes[] = { | |||
5627 | {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"}, | |||
5628 | {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"}, | |||
5629 | {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"}, | |||
5630 | {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"}, | |||
5631 | {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"}, | |||
5632 | }; | |||
5633 | ||||
5634 | const NoteType FreeBSDCoreNoteTypes[] = { | |||
5635 | {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"}, | |||
5636 | {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"}, | |||
5637 | {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"}, | |||
5638 | {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"}, | |||
5639 | {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"}, | |||
5640 | {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"}, | |||
5641 | {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"}, | |||
5642 | {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"}, | |||
5643 | {ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS, | |||
5644 | "NT_PROCSTAT_PSSTRINGS (ps_strings data)"}, | |||
5645 | {ELF::NT_FREEBSD_PROCSTAT_AUXV, "NT_PROCSTAT_AUXV (auxv data)"}, | |||
5646 | }; | |||
5647 | ||||
5648 | const NoteType FreeBSDNoteTypes[] = { | |||
5649 | {ELF::NT_FREEBSD_ABI_TAG, "NT_FREEBSD_ABI_TAG (ABI version tag)"}, | |||
5650 | {ELF::NT_FREEBSD_NOINIT_TAG, "NT_FREEBSD_NOINIT_TAG (no .init tag)"}, | |||
5651 | {ELF::NT_FREEBSD_ARCH_TAG, "NT_FREEBSD_ARCH_TAG (architecture tag)"}, | |||
5652 | {ELF::NT_FREEBSD_FEATURE_CTL, | |||
5653 | "NT_FREEBSD_FEATURE_CTL (FreeBSD feature control)"}, | |||
5654 | }; | |||
5655 | ||||
5656 | const NoteType NetBSDCoreNoteTypes[] = { | |||
5657 | {ELF::NT_NETBSDCORE_PROCINFO, | |||
5658 | "NT_NETBSDCORE_PROCINFO (procinfo structure)"}, | |||
5659 | {ELF::NT_NETBSDCORE_AUXV, "NT_NETBSDCORE_AUXV (ELF auxiliary vector data)"}, | |||
5660 | {ELF::NT_NETBSDCORE_LWPSTATUS, "PT_LWPSTATUS (ptrace_lwpstatus structure)"}, | |||
5661 | }; | |||
5662 | ||||
5663 | const NoteType OpenBSDCoreNoteTypes[] = { | |||
5664 | {ELF::NT_OPENBSD_PROCINFO, "NT_OPENBSD_PROCINFO (procinfo structure)"}, | |||
5665 | {ELF::NT_OPENBSD_AUXV, "NT_OPENBSD_AUXV (ELF auxiliary vector data)"}, | |||
5666 | {ELF::NT_OPENBSD_REGS, "NT_OPENBSD_REGS (regular registers)"}, | |||
5667 | {ELF::NT_OPENBSD_FPREGS, "NT_OPENBSD_FPREGS (floating point registers)"}, | |||
5668 | {ELF::NT_OPENBSD_WCOOKIE, "NT_OPENBSD_WCOOKIE (window cookie)"}, | |||
5669 | }; | |||
5670 | ||||
5671 | const NoteType AMDNoteTypes[] = { | |||
5672 | {ELF::NT_AMD_HSA_CODE_OBJECT_VERSION, | |||
5673 | "NT_AMD_HSA_CODE_OBJECT_VERSION (AMD HSA Code Object Version)"}, | |||
5674 | {ELF::NT_AMD_HSA_HSAIL, "NT_AMD_HSA_HSAIL (AMD HSA HSAIL Properties)"}, | |||
5675 | {ELF::NT_AMD_HSA_ISA_VERSION, "NT_AMD_HSA_ISA_VERSION (AMD HSA ISA Version)"}, | |||
5676 | {ELF::NT_AMD_HSA_METADATA, "NT_AMD_HSA_METADATA (AMD HSA Metadata)"}, | |||
5677 | {ELF::NT_AMD_HSA_ISA_NAME, "NT_AMD_HSA_ISA_NAME (AMD HSA ISA Name)"}, | |||
5678 | {ELF::NT_AMD_PAL_METADATA, "NT_AMD_PAL_METADATA (AMD PAL Metadata)"}, | |||
5679 | }; | |||
5680 | ||||
5681 | const NoteType AMDGPUNoteTypes[] = { | |||
5682 | {ELF::NT_AMDGPU_METADATA, "NT_AMDGPU_METADATA (AMDGPU Metadata)"}, | |||
5683 | }; | |||
5684 | ||||
5685 | const NoteType LLVMOMPOFFLOADNoteTypes[] = { | |||
5686 | {ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION, | |||
5687 | "NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)"}, | |||
5688 | {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER, | |||
5689 | "NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)"}, | |||
5690 | {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION, | |||
5691 | "NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)"}, | |||
5692 | }; | |||
5693 | ||||
5694 | const NoteType AndroidNoteTypes[] = { | |||
5695 | {ELF::NT_ANDROID_TYPE_IDENT, "NT_ANDROID_TYPE_IDENT"}, | |||
5696 | {ELF::NT_ANDROID_TYPE_KUSER, "NT_ANDROID_TYPE_KUSER"}, | |||
5697 | {ELF::NT_ANDROID_TYPE_MEMTAG, | |||
5698 | "NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)"}, | |||
5699 | }; | |||
5700 | ||||
5701 | const NoteType CoreNoteTypes[] = { | |||
5702 | {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"}, | |||
5703 | {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"}, | |||
5704 | {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"}, | |||
5705 | {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"}, | |||
5706 | {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"}, | |||
5707 | {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"}, | |||
5708 | {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"}, | |||
5709 | {ELF::NT_PSINFO, "NT_PSINFO (psinfo structure)"}, | |||
5710 | {ELF::NT_LWPSTATUS, "NT_LWPSTATUS (lwpstatus_t structure)"}, | |||
5711 | {ELF::NT_LWPSINFO, "NT_LWPSINFO (lwpsinfo_t structure)"}, | |||
5712 | {ELF::NT_WIN32PSTATUS, "NT_WIN32PSTATUS (win32_pstatus structure)"}, | |||
5713 | ||||
5714 | {ELF::NT_PPC_VMX, "NT_PPC_VMX (ppc Altivec registers)"}, | |||
5715 | {ELF::NT_PPC_VSX, "NT_PPC_VSX (ppc VSX registers)"}, | |||
5716 | {ELF::NT_PPC_TAR, "NT_PPC_TAR (ppc TAR register)"}, | |||
5717 | {ELF::NT_PPC_PPR, "NT_PPC_PPR (ppc PPR register)"}, | |||
5718 | {ELF::NT_PPC_DSCR, "NT_PPC_DSCR (ppc DSCR register)"}, | |||
5719 | {ELF::NT_PPC_EBB, "NT_PPC_EBB (ppc EBB registers)"}, | |||
5720 | {ELF::NT_PPC_PMU, "NT_PPC_PMU (ppc PMU registers)"}, | |||
5721 | {ELF::NT_PPC_TM_CGPR, "NT_PPC_TM_CGPR (ppc checkpointed GPR registers)"}, | |||
5722 | {ELF::NT_PPC_TM_CFPR, | |||
5723 | "NT_PPC_TM_CFPR (ppc checkpointed floating point registers)"}, | |||
5724 | {ELF::NT_PPC_TM_CVMX, | |||
5725 | "NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)"}, | |||
5726 | {ELF::NT_PPC_TM_CVSX, "NT_PPC_TM_CVSX (ppc checkpointed VSX registers)"}, | |||
5727 | {ELF::NT_PPC_TM_SPR, "NT_PPC_TM_SPR (ppc TM special purpose registers)"}, | |||
5728 | {ELF::NT_PPC_TM_CTAR, "NT_PPC_TM_CTAR (ppc checkpointed TAR register)"}, | |||
5729 | {ELF::NT_PPC_TM_CPPR, "NT_PPC_TM_CPPR (ppc checkpointed PPR register)"}, | |||
5730 | {ELF::NT_PPC_TM_CDSCR, "NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)"}, | |||
5731 | ||||
5732 | {ELF::NT_386_TLS, "NT_386_TLS (x86 TLS information)"}, | |||
5733 | {ELF::NT_386_IOPERM, "NT_386_IOPERM (x86 I/O permissions)"}, | |||
5734 | {ELF::NT_X86_XSTATE, "NT_X86_XSTATE (x86 XSAVE extended state)"}, | |||
5735 | ||||
5736 | {ELF::NT_S390_HIGH_GPRS, "NT_S390_HIGH_GPRS (s390 upper register halves)"}, | |||
5737 | {ELF::NT_S390_TIMER, "NT_S390_TIMER (s390 timer register)"}, | |||
5738 | {ELF::NT_S390_TODCMP, "NT_S390_TODCMP (s390 TOD comparator register)"}, | |||
5739 | {ELF::NT_S390_TODPREG, "NT_S390_TODPREG (s390 TOD programmable register)"}, | |||
5740 | {ELF::NT_S390_CTRS, "NT_S390_CTRS (s390 control registers)"}, | |||
5741 | {ELF::NT_S390_PREFIX, "NT_S390_PREFIX (s390 prefix register)"}, | |||
5742 | {ELF::NT_S390_LAST_BREAK, | |||
5743 | "NT_S390_LAST_BREAK (s390 last breaking event address)"}, | |||
5744 | {ELF::NT_S390_SYSTEM_CALL, | |||
5745 | "NT_S390_SYSTEM_CALL (s390 system call restart data)"}, | |||
5746 | {ELF::NT_S390_TDB, "NT_S390_TDB (s390 transaction diagnostic block)"}, | |||
5747 | {ELF::NT_S390_VXRS_LOW, | |||
5748 | "NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)"}, | |||
5749 | {ELF::NT_S390_VXRS_HIGH, "NT_S390_VXRS_HIGH (s390 vector registers 16-31)"}, | |||
5750 | {ELF::NT_S390_GS_CB, "NT_S390_GS_CB (s390 guarded-storage registers)"}, | |||
5751 | {ELF::NT_S390_GS_BC, | |||
5752 | "NT_S390_GS_BC (s390 guarded-storage broadcast control)"}, | |||
5753 | ||||
5754 | {ELF::NT_ARM_VFP, "NT_ARM_VFP (arm VFP registers)"}, | |||
5755 | {ELF::NT_ARM_TLS, "NT_ARM_TLS (AArch TLS registers)"}, | |||
5756 | {ELF::NT_ARM_HW_BREAK, | |||
5757 | "NT_ARM_HW_BREAK (AArch hardware breakpoint registers)"}, | |||
5758 | {ELF::NT_ARM_HW_WATCH, | |||
5759 | "NT_ARM_HW_WATCH (AArch hardware watchpoint registers)"}, | |||
5760 | {ELF::NT_ARM_SVE, "NT_ARM_SVE (AArch64 SVE registers)"}, | |||
5761 | {ELF::NT_ARM_PAC_MASK, | |||
5762 | "NT_ARM_PAC_MASK (AArch64 Pointer Authentication code masks)"}, | |||
5763 | {ELF::NT_ARM_SSVE, "NT_ARM_SSVE (AArch64 Streaming SVE registers)"}, | |||
5764 | {ELF::NT_ARM_ZA, "NT_ARM_ZA (AArch64 SME ZA registers)"}, | |||
5765 | {ELF::NT_ARM_ZT, "NT_ARM_ZT (AArch64 SME ZT registers)"}, | |||
5766 | ||||
5767 | {ELF::NT_FILE, "NT_FILE (mapped files)"}, | |||
5768 | {ELF::NT_PRXFPREG, "NT_PRXFPREG (user_xfpregs structure)"}, | |||
5769 | {ELF::NT_SIGINFO, "NT_SIGINFO (siginfo_t data)"}, | |||
5770 | }; | |||
5771 | ||||
5772 | template <class ELFT> | |||
5773 | StringRef getNoteTypeName(const typename ELFT::Note &Note, unsigned ELFType) { | |||
5774 | uint32_t Type = Note.getType(); | |||
5775 | auto FindNote = [&](ArrayRef<NoteType> V) -> StringRef { | |||
5776 | for (const NoteType &N : V) | |||
5777 | if (N.ID == Type) | |||
5778 | return N.Name; | |||
5779 | return ""; | |||
5780 | }; | |||
5781 | ||||
5782 | StringRef Name = Note.getName(); | |||
5783 | if (Name == "GNU") | |||
5784 | return FindNote(GNUNoteTypes); | |||
5785 | if (Name == "FreeBSD") { | |||
5786 | if (ELFType == ELF::ET_CORE) { | |||
5787 | // FreeBSD also places the generic core notes in the FreeBSD namespace. | |||
5788 | StringRef Result = FindNote(FreeBSDCoreNoteTypes); | |||
5789 | if (!Result.empty()) | |||
5790 | return Result; | |||
5791 | return FindNote(CoreNoteTypes); | |||
5792 | } else { | |||
5793 | return FindNote(FreeBSDNoteTypes); | |||
5794 | } | |||
5795 | } | |||
5796 | if (ELFType == ELF::ET_CORE && Name.startswith("NetBSD-CORE")) { | |||
5797 | StringRef Result = FindNote(NetBSDCoreNoteTypes); | |||
5798 | if (!Result.empty()) | |||
5799 | return Result; | |||
5800 | return FindNote(CoreNoteTypes); | |||
5801 | } | |||
5802 | if (ELFType == ELF::ET_CORE && Name.startswith("OpenBSD")) { | |||
5803 | // OpenBSD also places the generic core notes in the OpenBSD namespace. | |||
5804 | StringRef Result = FindNote(OpenBSDCoreNoteTypes); | |||
5805 | if (!Result.empty()) | |||
5806 | return Result; | |||
5807 | return FindNote(CoreNoteTypes); | |||
5808 | } | |||
5809 | if (Name == "AMD") | |||
5810 | return FindNote(AMDNoteTypes); | |||
5811 | if (Name == "AMDGPU") | |||
5812 | return FindNote(AMDGPUNoteTypes); | |||
5813 | if (Name == "LLVMOMPOFFLOAD") | |||
5814 | return FindNote(LLVMOMPOFFLOADNoteTypes); | |||
5815 | if (Name == "Android") | |||
5816 | return FindNote(AndroidNoteTypes); | |||
5817 | ||||
5818 | if (ELFType == ELF::ET_CORE) | |||
5819 | return FindNote(CoreNoteTypes); | |||
5820 | return FindNote(GenericNoteTypes); | |||
5821 | } | |||
5822 | ||||
5823 | template <class ELFT> | |||
5824 | static void processNotesHelper( | |||
5825 | const ELFDumper<ELFT> &Dumper, | |||
5826 | llvm::function_ref<void(std::optional<StringRef>, typename ELFT::Off, | |||
5827 | typename ELFT::Addr)> | |||
5828 | StartNotesFn, | |||
5829 | llvm::function_ref<Error(const typename ELFT::Note &, bool)> ProcessNoteFn, | |||
5830 | llvm::function_ref<void()> FinishNotesFn) { | |||
5831 | const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile(); | |||
5832 | bool IsCoreFile = Obj.getHeader().e_type == ELF::ET_CORE; | |||
5833 | ||||
5834 | ArrayRef<typename ELFT::Shdr> Sections = cantFail(Obj.sections()); | |||
5835 | if (!IsCoreFile && !Sections.empty()) { | |||
5836 | for (const typename ELFT::Shdr &S : Sections) { | |||
5837 | if (S.sh_type != SHT_NOTE) | |||
5838 | continue; | |||
5839 | StartNotesFn(expectedToStdOptional(Obj.getSectionName(S)), S.sh_offset, | |||
5840 | S.sh_size); | |||
5841 | Error Err = Error::success(); | |||
5842 | size_t I = 0; | |||
5843 | for (const typename ELFT::Note Note : Obj.notes(S, Err)) { | |||
5844 | if (Error E = ProcessNoteFn(Note, IsCoreFile)) | |||
5845 | Dumper.reportUniqueWarning( | |||
5846 | "unable to read note with index " + Twine(I) + " from the " + | |||
5847 | describe(Obj, S) + ": " + toString(std::move(E))); | |||
5848 | ++I; | |||
5849 | } | |||
5850 | if (Err) | |||
5851 | Dumper.reportUniqueWarning("unable to read notes from the " + | |||
5852 | describe(Obj, S) + ": " + | |||
5853 | toString(std::move(Err))); | |||
5854 | FinishNotesFn(); | |||
5855 | } | |||
5856 | return; | |||
5857 | } | |||
5858 | ||||
5859 | Expected<ArrayRef<typename ELFT::Phdr>> PhdrsOrErr = Obj.program_headers(); | |||
5860 | if (!PhdrsOrErr) { | |||
5861 | Dumper.reportUniqueWarning( | |||
5862 | "unable to read program headers to locate the PT_NOTE segment: " + | |||
5863 | toString(PhdrsOrErr.takeError())); | |||
5864 | return; | |||
5865 | } | |||
5866 | ||||
5867 | for (size_t I = 0, E = (*PhdrsOrErr).size(); I != E; ++I) { | |||
5868 | const typename ELFT::Phdr &P = (*PhdrsOrErr)[I]; | |||
5869 | if (P.p_type != PT_NOTE) | |||
5870 | continue; | |||
5871 | StartNotesFn(/*SecName=*/std::nullopt, P.p_offset, P.p_filesz); | |||
5872 | Error Err = Error::success(); | |||
5873 | size_t Index = 0; | |||
5874 | for (const typename ELFT::Note Note : Obj.notes(P, Err)) { | |||
5875 | if (Error E = ProcessNoteFn(Note, IsCoreFile)) | |||
5876 | Dumper.reportUniqueWarning("unable to read note with index " + | |||
5877 | Twine(Index) + | |||
5878 | " from the PT_NOTE segment with index " + | |||
5879 | Twine(I) + ": " + toString(std::move(E))); | |||
5880 | ++Index; | |||
5881 | } | |||
5882 | if (Err) | |||
5883 | Dumper.reportUniqueWarning( | |||
5884 | "unable to read notes from the PT_NOTE segment with index " + | |||
5885 | Twine(I) + ": " + toString(std::move(Err))); | |||
5886 | FinishNotesFn(); | |||
5887 | } | |||
5888 | } | |||
5889 | ||||
5890 | template <class ELFT> void GNUELFDumper<ELFT>::printNotes() { | |||
5891 | bool IsFirstHeader = true; | |||
5892 | auto PrintHeader = [&](std::optional<StringRef> SecName, | |||
5893 | const typename ELFT::Off Offset, | |||
5894 | const typename ELFT::Addr Size) { | |||
5895 | // Print a newline between notes sections to match GNU readelf. | |||
5896 | if (!IsFirstHeader) { | |||
5897 | OS << '\n'; | |||
5898 | } else { | |||
5899 | IsFirstHeader = false; | |||
5900 | } | |||
5901 | ||||
5902 | OS << "Displaying notes found "; | |||
5903 | ||||
5904 | if (SecName) | |||
5905 | OS << "in: " << *SecName << "\n"; | |||
5906 | else | |||
5907 | OS << "at file offset " << format_hex(Offset, 10) << " with length " | |||
5908 | << format_hex(Size, 10) << ":\n"; | |||
5909 | ||||
5910 | OS << " Owner Data size \tDescription\n"; | |||
5911 | }; | |||
5912 | ||||
5913 | auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error { | |||
5914 | StringRef Name = Note.getName(); | |||
5915 | ArrayRef<uint8_t> Descriptor = Note.getDesc(); | |||
5916 | Elf_Word Type = Note.getType(); | |||
5917 | ||||
5918 | // Print the note owner/type. | |||
5919 | OS << " " << left_justify(Name, 20) << ' ' | |||
5920 | << format_hex(Descriptor.size(), 10) << '\t'; | |||
5921 | ||||
5922 | StringRef NoteType = | |||
5923 | getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type); | |||
5924 | if (!NoteType.empty()) | |||
5925 | OS << NoteType << '\n'; | |||
5926 | else | |||
5927 | OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n"; | |||
5928 | ||||
5929 | // Print the description, or fallback to printing raw bytes for unknown | |||
5930 | // owners/if we fail to pretty-print the contents. | |||
5931 | if (Name == "GNU") { | |||
5932 | if (printGNUNote<ELFT>(OS, Type, Descriptor)) | |||
5933 | return Error::success(); | |||
5934 | } else if (Name == "FreeBSD") { | |||
5935 | if (std::optional<FreeBSDNote> N = | |||
5936 | getFreeBSDNote<ELFT>(Type, Descriptor, IsCore)) { | |||
5937 | OS << " " << N->Type << ": " << N->Value << '\n'; | |||
5938 | return Error::success(); | |||
5939 | } | |||
5940 | } else if (Name == "AMD") { | |||
5941 | const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); | |||
5942 | if (!N.Type.empty()) { | |||
5943 | OS << " " << N.Type << ":\n " << N.Value << '\n'; | |||
5944 | return Error::success(); | |||
5945 | } | |||
5946 | } else if (Name == "AMDGPU") { | |||
5947 | const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); | |||
5948 | if (!N.Type.empty()) { | |||
5949 | OS << " " << N.Type << ":\n " << N.Value << '\n'; | |||
5950 | return Error::success(); | |||
5951 | } | |||
5952 | } else if (Name == "LLVMOMPOFFLOAD") { | |||
5953 | if (printLLVMOMPOFFLOADNote<ELFT>(OS, Type, Descriptor)) | |||
5954 | return Error::success(); | |||
5955 | } else if (Name == "CORE") { | |||
5956 | if (Type == ELF::NT_FILE) { | |||
5957 | DataExtractor DescExtractor(Descriptor, | |||
5958 | ELFT::TargetEndianness == support::little, | |||
5959 | sizeof(Elf_Addr)); | |||
5960 | if (Expected<CoreNote> NoteOrErr = readCoreNote(DescExtractor)) { | |||
5961 | printCoreNote<ELFT>(OS, *NoteOrErr); | |||
5962 | return Error::success(); | |||
5963 | } else { | |||
5964 | return NoteOrErr.takeError(); | |||
5965 | } | |||
5966 | } | |||
5967 | } else if (Name == "Android") { | |||
5968 | if (printAndroidNote(OS, Type, Descriptor)) | |||
5969 | return Error::success(); | |||
5970 | } | |||
5971 | if (!Descriptor.empty()) { | |||
5972 | OS << " description data:"; | |||
5973 | for (uint8_t B : Descriptor) | |||
5974 | OS << " " << format("%02x", B); | |||
5975 | OS << '\n'; | |||
5976 | } | |||
5977 | return Error::success(); | |||
5978 | }; | |||
5979 | ||||
5980 | processNotesHelper(*this, /*StartNotesFn=*/PrintHeader, | |||
5981 | /*ProcessNoteFn=*/ProcessNote, /*FinishNotesFn=*/[]() {}); | |||
5982 | } | |||
5983 | ||||
5984 | template <class ELFT> | |||
5985 | ArrayRef<uint8_t> | |||
5986 | ELFDumper<ELFT>::getMemtagGlobalsSectionContents(uint64_t ExpectedAddr) { | |||
5987 | for (const typename ELFT::Shdr &Sec : cantFail(Obj.sections())) { | |||
5988 | if (Sec.sh_type != SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC) | |||
5989 | continue; | |||
5990 | if (Sec.sh_addr != ExpectedAddr) { | |||
5991 | reportUniqueWarning( | |||
5992 | "SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section was unexpectedly at 0x" + | |||
5993 | Twine::utohexstr(Sec.sh_addr) + | |||
5994 | ", when DT_AARCH64_MEMTAG_GLOBALS says it should be at 0x" + | |||
5995 | Twine::utohexstr(ExpectedAddr)); | |||
5996 | return ArrayRef<uint8_t>(); | |||
5997 | } | |||
5998 | Expected<ArrayRef<uint8_t>> Contents = Obj.getSectionContents(Sec); | |||
5999 | if (auto E = Contents.takeError()) { | |||
6000 | reportUniqueWarning( | |||
6001 | "couldn't get SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section contents: " + | |||
6002 | toString(std::move(E))); | |||
6003 | return ArrayRef<uint8_t>(); | |||
6004 | } | |||
6005 | return Contents.get(); | |||
6006 | } | |||
6007 | return ArrayRef<uint8_t>(); | |||
6008 | } | |||
6009 | ||||
6010 | // Reserve the lower three bits of the first byte of the step distance when | |||
6011 | // encoding the memtag descriptors. Found to be the best overall size tradeoff | |||
6012 | // when compiling Android T with full MTE globals enabled. | |||
6013 | constexpr uint64_t MemtagStepVarintReservedBits = 3; | |||
6014 | constexpr uint64_t MemtagGranuleSize = 16; | |||
6015 | ||||
6016 | template <typename ELFT> void ELFDumper<ELFT>::printMemtag() { | |||
6017 | if (Obj.getHeader().e_machine != EM_AARCH64) return; | |||
6018 | std::vector<std::pair<std::string, std::string>> DynamicEntries; | |||
6019 | uint64_t MemtagGlobalsSz = 0; | |||
6020 | uint64_t MemtagGlobals = 0; | |||
6021 | for (const typename ELFT::Dyn &Entry : dynamic_table()) { | |||
6022 | uintX_t Tag = Entry.getTag(); | |||
6023 | switch (Tag) { | |||
6024 | case DT_AARCH64_MEMTAG_GLOBALSSZ: | |||
6025 | MemtagGlobalsSz = Entry.getVal(); | |||
6026 | DynamicEntries.emplace_back(Obj.getDynamicTagAsString(Tag), | |||
6027 | getDynamicEntry(Tag, Entry.getVal())); | |||
6028 | break; | |||
6029 | case DT_AARCH64_MEMTAG_GLOBALS: | |||
6030 | MemtagGlobals = Entry.getVal(); | |||
6031 | DynamicEntries.emplace_back(Obj.getDynamicTagAsString(Tag), | |||
6032 | getDynamicEntry(Tag, Entry.getVal())); | |||
6033 | break; | |||
6034 | case DT_AARCH64_MEMTAG_MODE: | |||
6035 | case DT_AARCH64_MEMTAG_HEAP: | |||
6036 | case DT_AARCH64_MEMTAG_STACK: | |||
6037 | DynamicEntries.emplace_back(Obj.getDynamicTagAsString(Tag), | |||
6038 | getDynamicEntry(Tag, Entry.getVal())); | |||
6039 | break; | |||
6040 | } | |||
6041 | } | |||
6042 | ||||
6043 | ArrayRef<uint8_t> AndroidNoteDesc; | |||
6044 | auto FindAndroidNote = [&](const Elf_Note &Note, bool IsCore) -> Error { | |||
6045 | if (Note.getName() == "Android" && | |||
6046 | Note.getType() == ELF::NT_ANDROID_TYPE_MEMTAG) | |||
6047 | AndroidNoteDesc = Note.getDesc(); | |||
6048 | return Error::success(); | |||
6049 | }; | |||
6050 | ||||
6051 | processNotesHelper( | |||
6052 | *this, | |||
6053 | /*StartNotesFn=*/ | |||
6054 | [](std::optional<StringRef>, const typename ELFT::Off, | |||
6055 | const typename ELFT::Addr) {}, | |||
6056 | /*ProcessNoteFn=*/FindAndroidNote, /*FinishNotesFn=*/[]() {}); | |||
6057 | ||||
6058 | ArrayRef<uint8_t> Contents = getMemtagGlobalsSectionContents(MemtagGlobals); | |||
6059 | if (Contents.size() != MemtagGlobalsSz) { | |||
6060 | reportUniqueWarning( | |||
6061 | "mismatch between DT_AARCH64_MEMTAG_GLOBALSSZ (0x" + | |||
6062 | Twine::utohexstr(MemtagGlobalsSz) + | |||
6063 | ") and SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section size (0x" + | |||
6064 | Twine::utohexstr(Contents.size()) + ")"); | |||
6065 | Contents = ArrayRef<uint8_t>(); | |||
6066 | } | |||
6067 | ||||
6068 | std::vector<std::pair<uint64_t, uint64_t>> GlobalDescriptors; | |||
6069 | uint64_t Address = 0; | |||
6070 | // See the AArch64 MemtagABI document for a description of encoding scheme: | |||
6071 | // https://github.com/ARM-software/abi-aa/blob/main/memtagabielf64/memtagabielf64.rst#83encoding-of-sht_aarch64_memtag_globals_dynamic | |||
6072 | for (size_t I = 0; I < Contents.size();) { | |||
6073 | const char *Error = nullptr; | |||
6074 | unsigned DecodedBytes = 0; | |||
6075 | uint64_t Value = decodeULEB128(Contents.data() + I, &DecodedBytes, | |||
6076 | Contents.end(), &Error); | |||
6077 | I += DecodedBytes; | |||
6078 | if (Error) { | |||
6079 | reportUniqueWarning( | |||
6080 | "error decoding distance uleb, " + Twine(DecodedBytes) + | |||
6081 | " byte(s) into SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC: " + Twine(Error)); | |||
6082 | GlobalDescriptors.clear(); | |||
6083 | break; | |||
6084 | } | |||
6085 | uint64_t Distance = Value >> MemtagStepVarintReservedBits; | |||
6086 | uint64_t GranulesToTag = Value & ((1 << MemtagStepVarintReservedBits) - 1); | |||
6087 | if (GranulesToTag == 0) { | |||
6088 | GranulesToTag = decodeULEB128(Contents.data() + I, &DecodedBytes, | |||
6089 | Contents.end(), &Error) + | |||
6090 | 1; | |||
6091 | I += DecodedBytes; | |||
6092 | if (Error) { | |||
6093 | reportUniqueWarning( | |||
6094 | "error decoding size-only uleb, " + Twine(DecodedBytes) + | |||
6095 | " byte(s) into SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC: " + Twine(Error)); | |||
6096 | GlobalDescriptors.clear(); | |||
6097 | break; | |||
6098 | } | |||
6099 | } | |||
6100 | Address += Distance * MemtagGranuleSize; | |||
6101 | GlobalDescriptors.emplace_back(Address, GranulesToTag * MemtagGranuleSize); | |||
6102 | Address += GranulesToTag * MemtagGranuleSize; | |||
6103 | } | |||
6104 | ||||
6105 | printMemtag(DynamicEntries, AndroidNoteDesc, GlobalDescriptors); | |||
6106 | } | |||
6107 | ||||
6108 | template <class ELFT> void GNUELFDumper<ELFT>::printELFLinkerOptions() { | |||
6109 | OS << "printELFLinkerOptions not implemented!\n"; | |||
6110 | } | |||
6111 | ||||
6112 | template <class ELFT> | |||
6113 | void ELFDumper<ELFT>::printDependentLibsHelper( | |||
6114 | function_ref<void(const Elf_Shdr &)> OnSectionStart, | |||
6115 | function_ref<void(StringRef, uint64_t)> OnLibEntry) { | |||
6116 | auto Warn = [this](unsigned SecNdx, StringRef Msg) { | |||
6117 | this->reportUniqueWarning("SHT_LLVM_DEPENDENT_LIBRARIES section at index " + | |||
6118 | Twine(SecNdx) + " is broken: " + Msg); | |||
6119 | }; | |||
6120 | ||||
6121 | unsigned I = -1; | |||
6122 | for (const Elf_Shdr &Shdr : cantFail(Obj.sections())) { | |||
6123 | ++I; | |||
6124 | if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES) | |||
6125 | continue; | |||
6126 | ||||
6127 | OnSectionStart(Shdr); | |||
6128 | ||||
6129 | Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Shdr); | |||
6130 | if (!ContentsOrErr) { | |||
6131 | Warn(I, toString(ContentsOrErr.takeError())); | |||
6132 | continue; | |||
6133 | } | |||
6134 | ||||
6135 | ArrayRef<uint8_t> Contents = *ContentsOrErr; | |||
6136 | if (!Contents.empty() && Contents.back() != 0) { | |||
6137 | Warn(I, "the content is not null-terminated"); | |||
6138 | continue; | |||
6139 | } | |||
6140 | ||||
6141 | for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) { | |||
6142 | StringRef Lib((const char *)I); | |||
6143 | OnLibEntry(Lib, I - Contents.begin()); | |||
6144 | I += Lib.size() + 1; | |||
6145 | } | |||
6146 | } | |||
6147 | } | |||
6148 | ||||
6149 | template <class ELFT> | |||
6150 | void ELFDumper<ELFT>::forEachRelocationDo( | |||
6151 | const Elf_Shdr &Sec, bool RawRelr, | |||
6152 | llvm::function_ref<void(const Relocation<ELFT> &, unsigned, | |||
6153 | const Elf_Shdr &, const Elf_Shdr *)> | |||
6154 | RelRelaFn, | |||
6155 | llvm::function_ref<void(const Elf_Relr &)> RelrFn) { | |||
6156 | auto Warn = [&](Error &&E, | |||
6157 | const Twine &Prefix = "unable to read relocations from") { | |||
6158 | this->reportUniqueWarning(Prefix + " " + describe(Sec) + ": " + | |||
6159 | toString(std::move(E))); | |||
6160 | }; | |||
6161 | ||||
6162 | // SHT_RELR/SHT_ANDROID_RELR sections do not have an associated symbol table. | |||
6163 | // For them we should not treat the value of the sh_link field as an index of | |||
6164 | // a symbol table. | |||
6165 | const Elf_Shdr *SymTab; | |||
6166 | if (Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_RELR) { | |||
6167 | Expected<const Elf_Shdr *> SymTabOrErr = Obj.getSection(Sec.sh_link); | |||
6168 | if (!SymTabOrErr) { | |||
6169 | Warn(SymTabOrErr.takeError(), "unable to locate a symbol table for"); | |||
6170 | return; | |||
6171 | } | |||
6172 | SymTab = *SymTabOrErr; | |||
6173 | } | |||
6174 | ||||
6175 | unsigned RelNdx = 0; | |||
6176 | const bool IsMips64EL = this->Obj.isMips64EL(); | |||
6177 | switch (Sec.sh_type) { | |||
6178 | case ELF::SHT_REL: | |||
6179 | if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(Sec)) { | |||
6180 | for (const Elf_Rel &R : *RangeOrErr) | |||
6181 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
| ||||
6182 | } else { | |||
6183 | Warn(RangeOrErr.takeError()); | |||
6184 | } | |||
6185 | break; | |||
6186 | case ELF::SHT_RELA: | |||
6187 | if (Expected<Elf_Rela_Range> RangeOrErr = Obj.relas(Sec)) { | |||
6188 | for (const Elf_Rela &R : *RangeOrErr) | |||
6189 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
6190 | } else { | |||
6191 | Warn(RangeOrErr.takeError()); | |||
6192 | } | |||
6193 | break; | |||
6194 | case ELF::SHT_RELR: | |||
6195 | case ELF::SHT_ANDROID_RELR: { | |||
6196 | Expected<Elf_Relr_Range> RangeOrErr = Obj.relrs(Sec); | |||
6197 | if (!RangeOrErr) { | |||
6198 | Warn(RangeOrErr.takeError()); | |||
6199 | break; | |||
6200 | } | |||
6201 | if (RawRelr) { | |||
6202 | for (const Elf_Relr &R : *RangeOrErr) | |||
6203 | RelrFn(R); | |||
6204 | break; | |||
6205 | } | |||
6206 | ||||
6207 | for (const Elf_Rel &R : Obj.decode_relrs(*RangeOrErr)) | |||
6208 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, | |||
6209 | /*SymTab=*/nullptr); | |||
6210 | break; | |||
6211 | } | |||
6212 | case ELF::SHT_ANDROID_REL: | |||
6213 | case ELF::SHT_ANDROID_RELA: | |||
6214 | if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj.android_relas(Sec)) { | |||
6215 | for (const Elf_Rela &R : *RelasOrErr) | |||
6216 | RelRelaFn(Relocation<ELFT>(R, IsMips64EL), RelNdx++, Sec, SymTab); | |||
6217 | } else { | |||
6218 | Warn(RelasOrErr.takeError()); | |||
6219 | } | |||
6220 | break; | |||
6221 | } | |||
6222 | } | |||
6223 | ||||
6224 | template <class ELFT> | |||
6225 | StringRef ELFDumper<ELFT>::getPrintableSectionName(const Elf_Shdr &Sec) const { | |||
6226 | StringRef Name = "<?>"; | |||
6227 | if (Expected<StringRef> SecNameOrErr = | |||
6228 | Obj.getSectionName(Sec, this->WarningHandler)) | |||
6229 | Name = *SecNameOrErr; | |||
6230 | else | |||
6231 | this->reportUniqueWarning("unable to get the name of " + describe(Sec) + | |||
6232 | ": " + toString(SecNameOrErr.takeError())); | |||
6233 | return Name; | |||
6234 | } | |||
6235 | ||||
6236 | template <class ELFT> void GNUELFDumper<ELFT>::printDependentLibs() { | |||
6237 | bool SectionStarted = false; | |||
6238 | struct NameOffset { | |||
6239 | StringRef Name; | |||
6240 | uint64_t Offset; | |||
6241 | }; | |||
6242 | std::vector<NameOffset> SecEntries; | |||
6243 | NameOffset Current; | |||
6244 | auto PrintSection = [&]() { | |||
6245 | OS << "Dependent libraries section " << Current.Name << " at offset " | |||
6246 | << format_hex(Current.Offset, 1) << " contains " << SecEntries.size() | |||
6247 | << " entries:\n"; | |||
6248 | for (NameOffset Entry : SecEntries) | |||
6249 | OS << " [" << format("%6" PRIx64"l" "x", Entry.Offset) << "] " << Entry.Name | |||
6250 | << "\n"; | |||
6251 | OS << "\n"; | |||
6252 | SecEntries.clear(); | |||
6253 | }; | |||
6254 | ||||
6255 | auto OnSectionStart = [&](const Elf_Shdr &Shdr) { | |||
6256 | if (SectionStarted) | |||
6257 | PrintSection(); | |||
6258 | SectionStarted = true; | |||
6259 | Current.Offset = Shdr.sh_offset; | |||
6260 | Current.Name = this->getPrintableSectionName(Shdr); | |||
6261 | }; | |||
6262 | auto OnLibEntry = [&](StringRef Lib, uint64_t Offset) { | |||
6263 | SecEntries.push_back(NameOffset{Lib, Offset}); | |||
6264 | }; | |||
6265 | ||||
6266 | this->printDependentLibsHelper(OnSectionStart, OnLibEntry); | |||
6267 | if (SectionStarted) | |||
6268 | PrintSection(); | |||
6269 | } | |||
6270 | ||||
6271 | template <class ELFT> | |||
6272 | SmallVector<uint32_t> ELFDumper<ELFT>::getSymbolIndexesForFunctionAddress( | |||
6273 | uint64_t SymValue, std::optional<const Elf_Shdr *> FunctionSec) { | |||
6274 | SmallVector<uint32_t> SymbolIndexes; | |||
6275 | if (!this->AddressToIndexMap) { | |||
6276 | // Populate the address to index map upon the first invocation of this | |||
6277 | // function. | |||
6278 | this->AddressToIndexMap.emplace(); | |||
6279 | if (this->DotSymtabSec) { | |||
6280 | if (Expected<Elf_Sym_Range> SymsOrError = | |||
6281 | Obj.symbols(this->DotSymtabSec)) { | |||
6282 | uint32_t Index = (uint32_t)-1; | |||
6283 | for (const Elf_Sym &Sym : *SymsOrError) { | |||
6284 | ++Index; | |||
6285 | ||||
6286 | if (Sym.st_shndx == ELF::SHN_UNDEF || Sym.getType() != ELF::STT_FUNC) | |||
6287 | continue; | |||
6288 | ||||
6289 | Expected<uint64_t> SymAddrOrErr = | |||
6290 | ObjF.toSymbolRef(this->DotSymtabSec, Index).getAddress(); | |||
6291 | if (!SymAddrOrErr) { | |||
6292 | std::string Name = this->getStaticSymbolName(Index); | |||
6293 | reportUniqueWarning("unable to get address of symbol '" + Name + | |||
6294 | "': " + toString(SymAddrOrErr.takeError())); | |||
6295 | return SymbolIndexes; | |||
6296 | } | |||
6297 | ||||
6298 | (*this->AddressToIndexMap)[*SymAddrOrErr].push_back(Index); | |||
6299 | } | |||
6300 | } else { | |||
6301 | reportUniqueWarning("unable to read the symbol table: " + | |||
6302 | toString(SymsOrError.takeError())); | |||
6303 | } | |||
6304 | } | |||
6305 | } | |||
6306 | ||||
6307 | auto Symbols = this->AddressToIndexMap->find(SymValue); | |||
6308 | if (Symbols == this->AddressToIndexMap->end()) | |||
6309 | return SymbolIndexes; | |||
6310 | ||||
6311 | for (uint32_t Index : Symbols->second) { | |||
6312 | // Check if the symbol is in the right section. FunctionSec == None | |||
6313 | // means "any section". | |||
6314 | if (FunctionSec) { | |||
6315 | const Elf_Sym &Sym = *cantFail(Obj.getSymbol(this->DotSymtabSec, Index)); | |||
6316 | if (Expected<const Elf_Shdr *> SecOrErr = | |||
6317 | Obj.getSection(Sym, this->DotSymtabSec, | |||
6318 | this->getShndxTable(this->DotSymtabSec))) { | |||
6319 | if (*FunctionSec != *SecOrErr) | |||
6320 | continue; | |||
6321 | } else { | |||
6322 | std::string Name = this->getStaticSymbolName(Index); | |||
6323 | // Note: it is impossible to trigger this error currently, it is | |||
6324 | // untested. | |||
6325 | reportUniqueWarning("unable to get section of symbol '" + Name + | |||
6326 | "': " + toString(SecOrErr.takeError())); | |||
6327 | return SymbolIndexes; | |||
6328 | } | |||
6329 | } | |||
6330 | ||||
6331 | SymbolIndexes.push_back(Index); | |||
6332 | } | |||
6333 | ||||
6334 | return SymbolIndexes; | |||
6335 | } | |||
6336 | ||||
6337 | template <class ELFT> | |||
6338 | bool ELFDumper<ELFT>::printFunctionStackSize( | |||
6339 | uint64_t SymValue, std::optional<const Elf_Shdr *> FunctionSec, | |||
6340 | const Elf_Shdr &StackSizeSec, DataExtractor Data, uint64_t *Offset) { | |||
6341 | SmallVector<uint32_t> FuncSymIndexes = | |||
6342 | this->getSymbolIndexesForFunctionAddress(SymValue, FunctionSec); | |||
6343 | if (FuncSymIndexes.empty()) | |||
6344 | reportUniqueWarning( | |||
6345 | "could not identify function symbol for stack size entry in " + | |||
6346 | describe(StackSizeSec)); | |||
6347 | ||||
6348 | // Extract the size. The expectation is that Offset is pointing to the right | |||
6349 | // place, i.e. past the function address. | |||
6350 | Error Err = Error::success(); | |||
6351 | uint64_t StackSize = Data.getULEB128(Offset, &Err); | |||
6352 | if (Err) { | |||
6353 | reportUniqueWarning("could not extract a valid stack size from " + | |||
6354 | describe(StackSizeSec) + ": " + | |||
6355 | toString(std::move(Err))); | |||
6356 | return false; | |||
6357 | } | |||
6358 | ||||
6359 | if (FuncSymIndexes.empty()) { | |||
6360 | printStackSizeEntry(StackSize, {"?"}); | |||
6361 | } else { | |||
6362 | SmallVector<std::string> FuncSymNames; | |||
6363 | for (uint32_t Index : FuncSymIndexes) | |||
6364 | FuncSymNames.push_back(this->getStaticSymbolName(Index)); | |||
6365 | printStackSizeEntry(StackSize, FuncSymNames); | |||
6366 | } | |||
6367 | ||||
6368 | return true; | |||
6369 | } | |||
6370 | ||||
6371 | template <class ELFT> | |||
6372 | void GNUELFDumper<ELFT>::printStackSizeEntry(uint64_t Size, | |||
6373 | ArrayRef<std::string> FuncNames) { | |||
6374 | OS.PadToColumn(2); | |||
6375 | OS << format_decimal(Size, 11); | |||
6376 | OS.PadToColumn(18); | |||
6377 | ||||
6378 | OS << join(FuncNames.begin(), FuncNames.end(), ", ") << "\n"; | |||
6379 | } | |||
6380 | ||||
6381 | template <class ELFT> | |||
6382 | void ELFDumper<ELFT>::printStackSize(const Relocation<ELFT> &R, | |||
6383 | const Elf_Shdr &RelocSec, unsigned Ndx, | |||
6384 | const Elf_Shdr *SymTab, | |||
6385 | const Elf_Shdr *FunctionSec, | |||
6386 | const Elf_Shdr &StackSizeSec, | |||
6387 | const RelocationResolver &Resolver, | |||
6388 | DataExtractor Data) { | |||
6389 | // This function ignores potentially erroneous input, unless it is directly | |||
6390 | // related to stack size reporting. | |||
6391 | const Elf_Sym *Sym = nullptr; | |||
6392 | Expected<RelSymbol<ELFT>> TargetOrErr = this->getRelocationTarget(R, SymTab); | |||
6393 | if (!TargetOrErr) | |||
6394 | reportUniqueWarning("unable to get the target of relocation with index " + | |||
6395 | Twine(Ndx) + " in " + describe(RelocSec) + ": " + | |||
6396 | toString(TargetOrErr.takeError())); | |||
6397 | else | |||
6398 | Sym = TargetOrErr->Sym; | |||
6399 | ||||
6400 | uint64_t RelocSymValue = 0; | |||
6401 | if (Sym) { | |||
6402 | Expected<const Elf_Shdr *> SectionOrErr = | |||
6403 | this->Obj.getSection(*Sym, SymTab, this->getShndxTable(SymTab)); | |||
6404 | if (!SectionOrErr) { | |||
6405 | reportUniqueWarning( | |||
6406 | "cannot identify the section for relocation symbol '" + | |||
6407 | (*TargetOrErr).Name + "': " + toString(SectionOrErr.takeError())); | |||
6408 | } else if (*SectionOrErr != FunctionSec) { | |||
6409 | reportUniqueWarning("relocation symbol '" + (*TargetOrErr).Name + | |||
6410 | "' is not in the expected section"); | |||
6411 | // Pretend that the symbol is in the correct section and report its | |||
6412 | // stack size anyway. | |||
6413 | FunctionSec = *SectionOrErr; | |||
6414 | } | |||
6415 | ||||
6416 | RelocSymValue = Sym->st_value; | |||
6417 | } | |||
6418 | ||||
6419 | uint64_t Offset = R.Offset; | |||
6420 | if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { | |||
6421 | reportUniqueWarning("found invalid relocation offset (0x" + | |||
6422 | Twine::utohexstr(Offset) + ") into " + | |||
6423 | describe(StackSizeSec) + | |||
6424 | " while trying to extract a stack size entry"); | |||
6425 | return; | |||
6426 | } | |||
6427 | ||||
6428 | uint64_t SymValue = Resolver(R.Type, Offset, RelocSymValue, | |||
6429 | Data.getAddress(&Offset), R.Addend.value_or(0)); | |||
6430 | this->printFunctionStackSize(SymValue, FunctionSec, StackSizeSec, Data, | |||
6431 | &Offset); | |||
6432 | } | |||
6433 | ||||
6434 | template <class ELFT> | |||
6435 | void ELFDumper<ELFT>::printNonRelocatableStackSizes( | |||
6436 | std::function<void()> PrintHeader) { | |||
6437 | // This function ignores potentially erroneous input, unless it is directly | |||
6438 | // related to stack size reporting. | |||
6439 | for (const Elf_Shdr &Sec : cantFail(Obj.sections())) { | |||
6440 | if (this->getPrintableSectionName(Sec) != ".stack_sizes") | |||
6441 | continue; | |||
6442 | PrintHeader(); | |||
6443 | ArrayRef<uint8_t> Contents = | |||
6444 | unwrapOrError(this->FileName, Obj.getSectionContents(Sec)); | |||
6445 | DataExtractor Data(Contents, Obj.isLE(), sizeof(Elf_Addr)); | |||
6446 | uint64_t Offset = 0; | |||
6447 | while (Offset < Contents.size()) { | |||
6448 | // The function address is followed by a ULEB representing the stack | |||
6449 | // size. Check for an extra byte before we try to process the entry. | |||
6450 | if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { | |||
6451 | reportUniqueWarning( | |||
6452 | describe(Sec) + | |||
6453 | " ended while trying to extract a stack size entry"); | |||
6454 | break; | |||
6455 | } | |||
6456 | uint64_t SymValue = Data.getAddress(&Offset); | |||
6457 | if (!printFunctionStackSize(SymValue, /*FunctionSec=*/std::nullopt, Sec, | |||
6458 | Data, &Offset)) | |||
6459 | break; | |||
6460 | } | |||
6461 | } | |||
6462 | } | |||
6463 | ||||
6464 | template <class ELFT> | |||
6465 | void ELFDumper<ELFT>::printRelocatableStackSizes( | |||
6466 | std::function<void()> PrintHeader) { | |||
6467 | // Build a map between stack size sections and their corresponding relocation | |||
6468 | // sections. | |||
6469 | auto IsMatch = [&](const Elf_Shdr &Sec) -> bool { | |||
6470 | StringRef SectionName; | |||
6471 | if (Expected<StringRef> NameOrErr = Obj.getSectionName(Sec)) | |||
6472 | SectionName = *NameOrErr; | |||
6473 | else | |||
6474 | consumeError(NameOrErr.takeError()); | |||
6475 | ||||
6476 | return SectionName == ".stack_sizes"; | |||
6477 | }; | |||
6478 | ||||
6479 | Expected<MapVector<const Elf_Shdr *, const Elf_Shdr *>> | |||
6480 | StackSizeRelocMapOrErr = Obj.getSectionAndRelocations(IsMatch); | |||
6481 | if (!StackSizeRelocMapOrErr) { | |||
6482 | reportUniqueWarning("unable to get stack size map section(s): " + | |||
6483 | toString(StackSizeRelocMapOrErr.takeError())); | |||
6484 | return; | |||
6485 | } | |||
6486 | ||||
6487 | for (const auto &StackSizeMapEntry : *StackSizeRelocMapOrErr) { | |||
6488 | PrintHeader(); | |||
6489 | const Elf_Shdr *StackSizesELFSec = StackSizeMapEntry.first; | |||
6490 | const Elf_Shdr *RelocSec = StackSizeMapEntry.second; | |||
6491 | ||||
6492 | // Warn about stack size sections without a relocation section. | |||
6493 | if (!RelocSec) { | |||
6494 | reportWarning(createError(".stack_sizes (" + describe(*StackSizesELFSec) + | |||
6495 | ") does not have a corresponding " | |||
6496 | "relocation section"), | |||
6497 | FileName); | |||
6498 | continue; | |||
6499 | } | |||
6500 | ||||
6501 | // A .stack_sizes section header's sh_link field is supposed to point | |||
6502 | // to the section that contains the functions whose stack sizes are | |||
6503 | // described in it. | |||
6504 | const Elf_Shdr *FunctionSec = unwrapOrError( | |||
6505 | this->FileName, Obj.getSection(StackSizesELFSec->sh_link)); | |||
6506 | ||||
6507 | SupportsRelocation IsSupportedFn; | |||
6508 | RelocationResolver Resolver; | |||
6509 | std::tie(IsSupportedFn, Resolver) = getRelocationResolver(this->ObjF); | |||
6510 | ArrayRef<uint8_t> Contents = | |||
6511 | unwrapOrError(this->FileName, Obj.getSectionContents(*StackSizesELFSec)); | |||
6512 | DataExtractor Data(Contents, Obj.isLE(), sizeof(Elf_Addr)); | |||
6513 | ||||
6514 | forEachRelocationDo( | |||
6515 | *RelocSec, /*RawRelr=*/false, | |||
6516 | [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec, | |||
6517 | const Elf_Shdr *SymTab) { | |||
6518 | if (!IsSupportedFn || !IsSupportedFn(R.Type)) { | |||
6519 | reportUniqueWarning( | |||
6520 | describe(*RelocSec) + | |||
6521 | " contains an unsupported relocation with index " + Twine(Ndx) + | |||
6522 | ": " + Obj.getRelocationTypeName(R.Type)); | |||
6523 | return; | |||
6524 | } | |||
6525 | ||||
6526 | this->printStackSize(R, *RelocSec, Ndx, SymTab, FunctionSec, | |||
6527 | *StackSizesELFSec, Resolver, Data); | |||
6528 | }, | |||
6529 | [](const Elf_Relr &) { | |||
6530 | 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" , 6531) | |||
6531 | "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" , 6531); | |||
6532 | }); | |||
6533 | } | |||
6534 | } | |||
6535 | ||||
6536 | template <class ELFT> | |||
6537 | void GNUELFDumper<ELFT>::printStackSizes() { | |||
6538 | bool HeaderHasBeenPrinted = false; | |||
6539 | auto PrintHeader = [&]() { | |||
6540 | if (HeaderHasBeenPrinted) | |||
6541 | return; | |||
6542 | OS << "\nStack Sizes:\n"; | |||
6543 | OS.PadToColumn(9); | |||
6544 | OS << "Size"; | |||
6545 | OS.PadToColumn(18); | |||
6546 | OS << "Functions\n"; | |||
6547 | HeaderHasBeenPrinted = true; | |||
6548 | }; | |||
6549 | ||||
6550 | // For non-relocatable objects, look directly for sections whose name starts | |||
6551 | // with .stack_sizes and process the contents. | |||
6552 | if (this->Obj.getHeader().e_type == ELF::ET_REL) | |||
6553 | this->printRelocatableStackSizes(PrintHeader); | |||
6554 | else | |||
6555 | this->printNonRelocatableStackSizes(PrintHeader); | |||
6556 | } | |||
6557 | ||||
6558 | template <class ELFT> | |||
6559 | void GNUELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { | |||
6560 | size_t Bias = ELFT::Is64Bits ? 8 : 0; | |||
6561 | auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { | |||
6562 | OS.PadToColumn(2); | |||
6563 | OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias); | |||
6564 | OS.PadToColumn(11 + Bias); | |||
6565 | OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)"; | |||
6566 | OS.PadToColumn(22 + Bias); | |||
6567 | OS << format_hex_no_prefix(*E, 8 + Bias); | |||
6568 | OS.PadToColumn(31 + 2 * Bias); | |||
6569 | OS << Purpose << "\n"; | |||
6570 | }; | |||
6571 | ||||
6572 | OS << (Parser.IsStatic ? "Static GOT:\n" : "Primary GOT:\n"); | |||
6573 | OS << " Canonical gp value: " | |||
6574 | << format_hex_no_prefix(Parser.getGp(), 8 + Bias) << "\n\n"; | |||
6575 | ||||
6576 | OS << " Reserved entries:\n"; | |||
6577 | if (ELFT::Is64Bits) | |||
6578 | OS << " Address Access Initial Purpose\n"; | |||
6579 | else | |||
6580 | OS << " Address Access Initial Purpose\n"; | |||
6581 | PrintEntry(Parser.getGotLazyResolver(), "Lazy resolver"); | |||
6582 | if (Parser.getGotModulePointer()) | |||
6583 | PrintEntry(Parser.getGotModulePointer(), "Module pointer (GNU extension)"); | |||
6584 | ||||
6585 | if (!Parser.getLocalEntries().empty()) { | |||
6586 | OS << "\n"; | |||
6587 | OS << " Local entries:\n"; | |||
6588 | if (ELFT::Is64Bits) | |||
6589 | OS << " Address Access Initial\n"; | |||
6590 | else | |||
6591 | OS << " Address Access Initial\n"; | |||
6592 | for (auto &E : Parser.getLocalEntries()) | |||
6593 | PrintEntry(&E, ""); | |||
6594 | } | |||
6595 | ||||
6596 | if (Parser.IsStatic) | |||
6597 | return; | |||
6598 | ||||
6599 | if (!Parser.getGlobalEntries().empty()) { | |||
6600 | OS << "\n"; | |||
6601 | OS << " Global entries:\n"; | |||
6602 | if (ELFT::Is64Bits) | |||
6603 | OS << " Address Access Initial Sym.Val." | |||
6604 | << " Type Ndx Name\n"; | |||
6605 | else | |||
6606 | OS << " Address Access Initial Sym.Val. Type Ndx Name\n"; | |||
6607 | ||||
6608 | DataRegion<Elf_Word> ShndxTable( | |||
6609 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
6610 | for (auto &E : Parser.getGlobalEntries()) { | |||
6611 | const Elf_Sym &Sym = *Parser.getGotSym(&E); | |||
6612 | const Elf_Sym &FirstSym = this->dynamic_symbols()[0]; | |||
6613 | std::string SymName = this->getFullSymbolName( | |||
6614 | Sym, &Sym - &FirstSym, ShndxTable, this->DynamicStringTable, false); | |||
6615 | ||||
6616 | OS.PadToColumn(2); | |||
6617 | OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias)); | |||
6618 | OS.PadToColumn(11 + Bias); | |||
6619 | OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)"; | |||
6620 | OS.PadToColumn(22 + Bias); | |||
6621 | OS << to_string(format_hex_no_prefix(E, 8 + Bias)); | |||
6622 | OS.PadToColumn(31 + 2 * Bias); | |||
6623 | OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); | |||
6624 | OS.PadToColumn(40 + 3 * Bias); | |||
6625 | OS << enumToString(Sym.getType(), ArrayRef(ElfSymbolTypes)); | |||
6626 | OS.PadToColumn(48 + 3 * Bias); | |||
6627 | OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), | |||
6628 | ShndxTable); | |||
6629 | OS.PadToColumn(52 + 3 * Bias); | |||
6630 | OS << SymName << "\n"; | |||
6631 | } | |||
6632 | } | |||
6633 | ||||
6634 | if (!Parser.getOtherEntries().empty()) | |||
6635 | OS << "\n Number of TLS and multi-GOT entries " | |||
6636 | << Parser.getOtherEntries().size() << "\n"; | |||
6637 | } | |||
6638 | ||||
6639 | template <class ELFT> | |||
6640 | void GNUELFDumper<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { | |||
6641 | size_t Bias = ELFT::Is64Bits ? 8 : 0; | |||
6642 | auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { | |||
6643 | OS.PadToColumn(2); | |||
6644 | OS << format_hex_no_prefix(Parser.getPltAddress(E), 8 + Bias); | |||
6645 | OS.PadToColumn(11 + Bias); | |||
6646 | OS << format_hex_no_prefix(*E, 8 + Bias); | |||
6647 | OS.PadToColumn(20 + 2 * Bias); | |||
6648 | OS << Purpose << "\n"; | |||
6649 | }; | |||
6650 | ||||
6651 | OS << "PLT GOT:\n\n"; | |||
6652 | ||||
6653 | OS << " Reserved entries:\n"; | |||
6654 | OS << " Address Initial Purpose\n"; | |||
6655 | PrintEntry(Parser.getPltLazyResolver(), "PLT lazy resolver"); | |||
6656 | if (Parser.getPltModulePointer()) | |||
6657 | PrintEntry(Parser.getPltModulePointer(), "Module pointer"); | |||
6658 | ||||
6659 | if (!Parser.getPltEntries().empty()) { | |||
6660 | OS << "\n"; | |||
6661 | OS << " Entries:\n"; | |||
6662 | OS << " Address Initial Sym.Val. Type Ndx Name\n"; | |||
6663 | DataRegion<Elf_Word> ShndxTable( | |||
6664 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
6665 | for (auto &E : Parser.getPltEntries()) { | |||
6666 | const Elf_Sym &Sym = *Parser.getPltSym(&E); | |||
6667 | const Elf_Sym &FirstSym = *cantFail( | |||
6668 | this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0)); | |||
6669 | std::string SymName = this->getFullSymbolName( | |||
6670 | Sym, &Sym - &FirstSym, ShndxTable, this->DynamicStringTable, false); | |||
6671 | ||||
6672 | OS.PadToColumn(2); | |||
6673 | OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias)); | |||
6674 | OS.PadToColumn(11 + Bias); | |||
6675 | OS << to_string(format_hex_no_prefix(E, 8 + Bias)); | |||
6676 | OS.PadToColumn(20 + 2 * Bias); | |||
6677 | OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); | |||
6678 | OS.PadToColumn(29 + 3 * Bias); | |||
6679 | OS << enumToString(Sym.getType(), ArrayRef(ElfSymbolTypes)); | |||
6680 | OS.PadToColumn(37 + 3 * Bias); | |||
6681 | OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), | |||
6682 | ShndxTable); | |||
6683 | OS.PadToColumn(41 + 3 * Bias); | |||
6684 | OS << SymName << "\n"; | |||
6685 | } | |||
6686 | } | |||
6687 | } | |||
6688 | ||||
6689 | template <class ELFT> | |||
6690 | Expected<const Elf_Mips_ABIFlags<ELFT> *> | |||
6691 | getMipsAbiFlagsSection(const ELFDumper<ELFT> &Dumper) { | |||
6692 | const typename ELFT::Shdr *Sec = Dumper.findSectionByName(".MIPS.abiflags"); | |||
6693 | if (Sec == nullptr) | |||
6694 | return nullptr; | |||
6695 | ||||
6696 | constexpr StringRef ErrPrefix = "unable to read the .MIPS.abiflags section: "; | |||
6697 | Expected<ArrayRef<uint8_t>> DataOrErr = | |||
6698 | Dumper.getElfObject().getELFFile().getSectionContents(*Sec); | |||
6699 | if (!DataOrErr) | |||
6700 | return createError(ErrPrefix + toString(DataOrErr.takeError())); | |||
6701 | ||||
6702 | if (DataOrErr->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) | |||
6703 | return createError(ErrPrefix + "it has a wrong size (" + | |||
6704 | Twine(DataOrErr->size()) + ")"); | |||
6705 | return reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(DataOrErr->data()); | |||
6706 | } | |||
6707 | ||||
6708 | template <class ELFT> void GNUELFDumper<ELFT>::printMipsABIFlags() { | |||
6709 | const Elf_Mips_ABIFlags<ELFT> *Flags = nullptr; | |||
6710 | if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = | |||
6711 | getMipsAbiFlagsSection(*this)) | |||
6712 | Flags = *SecOrErr; | |||
6713 | else | |||
6714 | this->reportUniqueWarning(SecOrErr.takeError()); | |||
6715 | if (!Flags) | |||
6716 | return; | |||
6717 | ||||
6718 | OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n"; | |||
6719 | OS << "ISA: MIPS" << int(Flags->isa_level); | |||
6720 | if (Flags->isa_rev > 1) | |||
6721 | OS << "r" << int(Flags->isa_rev); | |||
6722 | OS << "\n"; | |||
6723 | OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n"; | |||
6724 | OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n"; | |||
6725 | OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n"; | |||
6726 | OS << "FP ABI: " << enumToString(Flags->fp_abi, ArrayRef(ElfMipsFpABIType)) | |||
6727 | << "\n"; | |||
6728 | OS << "ISA Extension: " | |||
6729 | << enumToString(Flags->isa_ext, ArrayRef(ElfMipsISAExtType)) << "\n"; | |||
6730 | if (Flags->ases == 0) | |||
6731 | OS << "ASEs: None\n"; | |||
6732 | else | |||
6733 | // FIXME: Print each flag on a separate line. | |||
6734 | OS << "ASEs: " << printFlags(Flags->ases, ArrayRef(ElfMipsASEFlags)) | |||
6735 | << "\n"; | |||
6736 | OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n"; | |||
6737 | OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n"; | |||
6738 | OS << "\n"; | |||
6739 | } | |||
6740 | ||||
6741 | template <class ELFT> void LLVMELFDumper<ELFT>::printFileHeaders() { | |||
6742 | const Elf_Ehdr &E = this->Obj.getHeader(); | |||
6743 | { | |||
6744 | DictScope D(W, "ElfHeader"); | |||
6745 | { | |||
6746 | DictScope D(W, "Ident"); | |||
6747 | W.printBinary("Magic", | |||
6748 | ArrayRef<unsigned char>(E.e_ident).slice(ELF::EI_MAG0, 4)); | |||
6749 | W.printEnum("Class", E.e_ident[ELF::EI_CLASS], ArrayRef(ElfClass)); | |||
6750 | W.printEnum("DataEncoding", E.e_ident[ELF::EI_DATA], | |||
6751 | ArrayRef(ElfDataEncoding)); | |||
6752 | W.printNumber("FileVersion", E.e_ident[ELF::EI_VERSION]); | |||
6753 | ||||
6754 | auto OSABI = ArrayRef(ElfOSABI); | |||
6755 | if (E.e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH && | |||
6756 | E.e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) { | |||
6757 | switch (E.e_machine) { | |||
6758 | case ELF::EM_AMDGPU: | |||
6759 | OSABI = ArrayRef(AMDGPUElfOSABI); | |||
6760 | break; | |||
6761 | case ELF::EM_ARM: | |||
6762 | OSABI = ArrayRef(ARMElfOSABI); | |||
6763 | break; | |||
6764 | case ELF::EM_TI_C6000: | |||
6765 | OSABI = ArrayRef(C6000ElfOSABI); | |||
6766 | break; | |||
6767 | } | |||
6768 | } | |||
6769 | W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI); | |||
6770 | W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]); | |||
6771 | W.printBinary("Unused", | |||
6772 | ArrayRef<unsigned char>(E.e_ident).slice(ELF::EI_PAD)); | |||
6773 | } | |||
6774 | ||||
6775 | std::string TypeStr; | |||
6776 | if (const EnumEntry<unsigned> *Ent = getObjectFileEnumEntry(E.e_type)) { | |||
6777 | TypeStr = Ent->Name.str(); | |||
6778 | } else { | |||
6779 | if (E.e_type >= ET_LOPROC) | |||
6780 | TypeStr = "Processor Specific"; | |||
6781 | else if (E.e_type >= ET_LOOS) | |||
6782 | TypeStr = "OS Specific"; | |||
6783 | else | |||
6784 | TypeStr = "Unknown"; | |||
6785 | } | |||
6786 | W.printString("Type", TypeStr + " (0x" + utohexstr(E.e_type) + ")"); | |||
6787 | ||||
6788 | W.printEnum("Machine", E.e_machine, ArrayRef(ElfMachineType)); | |||
6789 | W.printNumber("Version", E.e_version); | |||
6790 | W.printHex("Entry", E.e_entry); | |||
6791 | W.printHex("ProgramHeaderOffset", E.e_phoff); | |||
6792 | W.printHex("SectionHeaderOffset", E.e_shoff); | |||
6793 | if (E.e_machine == EM_MIPS) | |||
6794 | W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderMipsFlags), | |||
6795 | unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), | |||
6796 | unsigned(ELF::EF_MIPS_MACH)); | |||
6797 | else if (E.e_machine == EM_AMDGPU) { | |||
6798 | switch (E.e_ident[ELF::EI_ABIVERSION]) { | |||
6799 | default: | |||
6800 | W.printHex("Flags", E.e_flags); | |||
6801 | break; | |||
6802 | case 0: | |||
6803 | // ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags. | |||
6804 | [[fallthrough]]; | |||
6805 | case ELF::ELFABIVERSION_AMDGPU_HSA_V3: | |||
6806 | W.printFlags("Flags", E.e_flags, | |||
6807 | ArrayRef(ElfHeaderAMDGPUFlagsABIVersion3), | |||
6808 | unsigned(ELF::EF_AMDGPU_MACH)); | |||
6809 | break; | |||
6810 | case ELF::ELFABIVERSION_AMDGPU_HSA_V4: | |||
6811 | case ELF::ELFABIVERSION_AMDGPU_HSA_V5: | |||
6812 | W.printFlags("Flags", E.e_flags, | |||
6813 | ArrayRef(ElfHeaderAMDGPUFlagsABIVersion4), | |||
6814 | unsigned(ELF::EF_AMDGPU_MACH), | |||
6815 | unsigned(ELF::EF_AMDGPU_FEATURE_XNACK_V4), | |||
6816 | unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4)); | |||
6817 | break; | |||
6818 | } | |||
6819 | } else if (E.e_machine == EM_RISCV) | |||
6820 | W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderRISCVFlags)); | |||
6821 | else if (E.e_machine == EM_AVR) | |||
6822 | W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderAVRFlags), | |||
6823 | unsigned(ELF::EF_AVR_ARCH_MASK)); | |||
6824 | else if (E.e_machine == EM_LOONGARCH) | |||
6825 | W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderLoongArchFlags), | |||
6826 | unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), | |||
6827 | unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); | |||
6828 | else if (E.e_machine == EM_XTENSA) | |||
6829 | W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderXtensaFlags), | |||
6830 | unsigned(ELF::EF_XTENSA_MACH)); | |||
6831 | else | |||
6832 | W.printFlags("Flags", E.e_flags); | |||
6833 | W.printNumber("HeaderSize", E.e_ehsize); | |||
6834 | W.printNumber("ProgramHeaderEntrySize", E.e_phentsize); | |||
6835 | W.printNumber("ProgramHeaderCount", E.e_phnum); | |||
6836 | W.printNumber("SectionHeaderEntrySize", E.e_shentsize); | |||
6837 | W.printString("SectionHeaderCount", | |||
6838 | getSectionHeadersNumString(this->Obj, this->FileName)); | |||
6839 | W.printString("StringTableSectionIndex", | |||
6840 | getSectionHeaderTableIndexString(this->Obj, this->FileName)); | |||
6841 | } | |||
6842 | } | |||
6843 | ||||
6844 | template <class ELFT> void LLVMELFDumper<ELFT>::printGroupSections() { | |||
6845 | DictScope Lists(W, "Groups"); | |||
6846 | std::vector<GroupSection> V = this->getGroups(); | |||
6847 | DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); | |||
6848 | for (const GroupSection &G : V) { | |||
6849 | DictScope D(W, "Group"); | |||
6850 | W.printNumber("Name", G.Name, G.ShName); | |||
6851 | W.printNumber("Index", G.Index); | |||
6852 | W.printNumber("Link", G.Link); | |||
6853 | W.printNumber("Info", G.Info); | |||
6854 | W.printHex("Type", getGroupType(G.Type), G.Type); | |||
6855 | W.printString("Signature", G.Signature); | |||
6856 | ||||
6857 | ListScope L(W, getGroupSectionHeaderName()); | |||
6858 | for (const GroupMember &GM : G.Members) { | |||
6859 | const GroupSection *MainGroup = Map[GM.Index]; | |||
6860 | if (MainGroup != &G) | |||
6861 | this->reportUniqueWarning( | |||
6862 | "section with index " + Twine(GM.Index) + | |||
6863 | ", included in the group section with index " + | |||
6864 | Twine(MainGroup->Index) + | |||
6865 | ", was also found in the group section with index " + | |||
6866 | Twine(G.Index)); | |||
6867 | printSectionGroupMembers(GM.Name, GM.Index); | |||
6868 | } | |||
6869 | } | |||
6870 | ||||
6871 | if (V.empty()) | |||
6872 | printEmptyGroupMessage(); | |||
6873 | } | |||
6874 | ||||
6875 | template <class ELFT> | |||
6876 | std::string LLVMELFDumper<ELFT>::getGroupSectionHeaderName() const { | |||
6877 | return "Section(s) in group"; | |||
6878 | } | |||
6879 | ||||
6880 | template <class ELFT> | |||
6881 | void LLVMELFDumper<ELFT>::printSectionGroupMembers(StringRef Name, | |||
6882 | uint64_t Idx) const { | |||
6883 | W.startLine() << Name << " (" << Idx << ")\n"; | |||
6884 | } | |||
6885 | ||||
6886 | template <class ELFT> void LLVMELFDumper<ELFT>::printRelocations() { | |||
6887 | ListScope D(W, "Relocations"); | |||
6888 | ||||
6889 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
6890 | if (!isRelocationSec<ELFT>(Sec)) | |||
6891 | continue; | |||
6892 | ||||
6893 | StringRef Name = this->getPrintableSectionName(Sec); | |||
6894 | unsigned SecNdx = &Sec - &cantFail(this->Obj.sections()).front(); | |||
6895 | printRelocationSectionInfo(Sec, Name, SecNdx); | |||
6896 | } | |||
6897 | } | |||
6898 | ||||
6899 | template <class ELFT> | |||
6900 | void LLVMELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) { | |||
6901 | W.startLine() << W.hex(R) << "\n"; | |||
6902 | } | |||
6903 | ||||
6904 | template <class ELFT> | |||
6905 | void LLVMELFDumper<ELFT>::printExpandedRelRelaReloc(const Relocation<ELFT> &R, | |||
6906 | StringRef SymbolName, | |||
6907 | StringRef RelocName) { | |||
6908 | DictScope Group(W, "Relocation"); | |||
6909 | W.printHex("Offset", R.Offset); | |||
6910 | W.printNumber("Type", RelocName, R.Type); | |||
6911 | W.printNumber("Symbol", !SymbolName.empty() ? SymbolName : "-", R.Symbol); | |||
6912 | if (R.Addend) | |||
6913 | W.printHex("Addend", (uintX_t)*R.Addend); | |||
6914 | } | |||
6915 | ||||
6916 | template <class ELFT> | |||
6917 | void LLVMELFDumper<ELFT>::printDefaultRelRelaReloc(const Relocation<ELFT> &R, | |||
6918 | StringRef SymbolName, | |||
6919 | StringRef RelocName) { | |||
6920 | raw_ostream &OS = W.startLine(); | |||
6921 | OS << W.hex(R.Offset) << " " << RelocName << " " | |||
6922 | << (!SymbolName.empty() ? SymbolName : "-"); | |||
6923 | if (R.Addend) | |||
6924 | OS << " " << W.hex((uintX_t)*R.Addend); | |||
6925 | OS << "\n"; | |||
6926 | } | |||
6927 | ||||
6928 | template <class ELFT> | |||
6929 | void LLVMELFDumper<ELFT>::printRelocationSectionInfo(const Elf_Shdr &Sec, | |||
6930 | StringRef Name, | |||
6931 | const unsigned SecNdx) { | |||
6932 | DictScope D(W, (Twine("Section (") + Twine(SecNdx) + ") " + Name).str()); | |||
6933 | this->printRelocationsHelper(Sec); | |||
6934 | } | |||
6935 | ||||
6936 | template <class ELFT> void LLVMELFDumper<ELFT>::printEmptyGroupMessage() const { | |||
6937 | W.startLine() << "There are no group sections in the file.\n"; | |||
6938 | } | |||
6939 | ||||
6940 | template <class ELFT> | |||
6941 | void LLVMELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R, | |||
6942 | const RelSymbol<ELFT> &RelSym) { | |||
6943 | StringRef SymbolName = RelSym.Name; | |||
6944 | SmallString<32> RelocName; | |||
6945 | this->Obj.getRelocationTypeName(R.Type, RelocName); | |||
6946 | ||||
6947 | if (opts::ExpandRelocs) { | |||
6948 | printExpandedRelRelaReloc(R, SymbolName, RelocName); | |||
6949 | } else { | |||
6950 | printDefaultRelRelaReloc(R, SymbolName, RelocName); | |||
6951 | } | |||
6952 | } | |||
6953 | ||||
6954 | template <class ELFT> void LLVMELFDumper<ELFT>::printSectionHeaders() { | |||
6955 | ListScope SectionsD(W, "Sections"); | |||
6956 | ||||
6957 | int SectionIndex = -1; | |||
6958 | std::vector<EnumEntry<unsigned>> FlagsList = | |||
6959 | getSectionFlagsForTarget(this->Obj.getHeader().e_ident[ELF::EI_OSABI], | |||
6960 | this->Obj.getHeader().e_machine); | |||
6961 | for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) { | |||
6962 | DictScope SectionD(W, "Section"); | |||
6963 | W.printNumber("Index", ++SectionIndex); | |||
6964 | W.printNumber("Name", this->getPrintableSectionName(Sec), Sec.sh_name); | |||
6965 | W.printHex("Type", | |||
6966 | object::getELFSectionTypeName(this->Obj.getHeader().e_machine, | |||
6967 | Sec.sh_type), | |||
6968 | Sec.sh_type); | |||
6969 | W.printFlags("Flags", Sec.sh_flags, ArrayRef(FlagsList)); | |||
6970 | W.printHex("Address", Sec.sh_addr); | |||
6971 | W.printHex("Offset", Sec.sh_offset); | |||
6972 | W.printNumber("Size", Sec.sh_size); | |||
6973 | W.printNumber("Link", Sec.sh_link); | |||
6974 | W.printNumber("Info", Sec.sh_info); | |||
6975 | W.printNumber("AddressAlignment", Sec.sh_addralign); | |||
6976 | W.printNumber("EntrySize", Sec.sh_entsize); | |||
6977 | ||||
6978 | if (opts::SectionRelocations) { | |||
6979 | ListScope D(W, "Relocations"); | |||
6980 | this->printRelocationsHelper(Sec); | |||
6981 | } | |||
6982 | ||||
6983 | if (opts::SectionSymbols) { | |||
6984 | ListScope D(W, "Symbols"); | |||
6985 | if (this->DotSymtabSec) { | |||
6986 | StringRef StrTable = unwrapOrError( | |||
6987 | this->FileName, | |||
6988 | this->Obj.getStringTableForSymtab(*this->DotSymtabSec)); | |||
6989 | ArrayRef<Elf_Word> ShndxTable = this->getShndxTable(this->DotSymtabSec); | |||
6990 | ||||
6991 | typename ELFT::SymRange Symbols = unwrapOrError( | |||
6992 | this->FileName, this->Obj.symbols(this->DotSymtabSec)); | |||
6993 | for (const Elf_Sym &Sym : Symbols) { | |||
6994 | const Elf_Shdr *SymSec = unwrapOrError( | |||
6995 | this->FileName, | |||
6996 | this->Obj.getSection(Sym, this->DotSymtabSec, ShndxTable)); | |||
6997 | if (SymSec == &Sec) | |||
6998 | printSymbol(Sym, &Sym - &Symbols[0], ShndxTable, StrTable, false, | |||
6999 | false); | |||
7000 | } | |||
7001 | } | |||
7002 | } | |||
7003 | ||||
7004 | if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { | |||
7005 | ArrayRef<uint8_t> Data = | |||
7006 | unwrapOrError(this->FileName, this->Obj.getSectionContents(Sec)); | |||
7007 | W.printBinaryBlock( | |||
7008 | "SectionData", | |||
7009 | StringRef(reinterpret_cast<const char *>(Data.data()), Data.size())); | |||
7010 | } | |||
7011 | } | |||
7012 | } | |||
7013 | ||||
7014 | template <class ELFT> | |||
7015 | void LLVMELFDumper<ELFT>::printSymbolSection( | |||
7016 | const Elf_Sym &Symbol, unsigned SymIndex, | |||
7017 | DataRegion<Elf_Word> ShndxTable) const { | |||
7018 | auto GetSectionSpecialType = [&]() -> std::optional<StringRef> { | |||
7019 | if (Symbol.isUndefined()) | |||
7020 | return StringRef("Undefined"); | |||
7021 | if (Symbol.isProcessorSpecific()) | |||
7022 | return StringRef("Processor Specific"); | |||
7023 | if (Symbol.isOSSpecific()) | |||
7024 | return StringRef("Operating System Specific"); | |||
7025 | if (Symbol.isAbsolute()) | |||
7026 | return StringRef("Absolute"); | |||
7027 | if (Symbol.isCommon()) | |||
7028 | return StringRef("Common"); | |||
7029 | if (Symbol.isReserved() && Symbol.st_shndx != SHN_XINDEX) | |||
7030 | return StringRef("Reserved"); | |||
7031 | return std::nullopt; | |||
7032 | }; | |||
7033 | ||||
7034 | if (std::optional<StringRef> Type = GetSectionSpecialType()) { | |||
7035 | W.printHex("Section", *Type, Symbol.st_shndx); | |||
7036 | return; | |||
7037 | } | |||
7038 | ||||
7039 | Expected<unsigned> SectionIndex = | |||
7040 | this->getSymbolSectionIndex(Symbol, SymIndex, ShndxTable); | |||
7041 | if (!SectionIndex) { | |||
7042 | 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", 7044, __extension__ __PRETTY_FUNCTION__)) | |||
7043 | "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", 7044, __extension__ __PRETTY_FUNCTION__)) | |||
7044 | "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", 7044, __extension__ __PRETTY_FUNCTION__)); | |||
7045 | this->reportUniqueWarning(SectionIndex.takeError()); | |||
7046 | W.printHex("Section", "Reserved", SHN_XINDEX); | |||
7047 | return; | |||
7048 | } | |||
7049 | ||||
7050 | Expected<StringRef> SectionName = | |||
7051 | this->getSymbolSectionName(Symbol, *SectionIndex); | |||
7052 | if (!SectionName) { | |||
7053 | // Don't report an invalid section name if the section headers are missing. | |||
7054 | // In such situations, all sections will be "invalid". | |||
7055 | if (!this->ObjF.sections().empty()) | |||
7056 | this->reportUniqueWarning(SectionName.takeError()); | |||
7057 | else | |||
7058 | consumeError(SectionName.takeError()); | |||
7059 | W.printHex("Section", "<?>", *SectionIndex); | |||
7060 | } else { | |||
7061 | W.printHex("Section", *SectionName, *SectionIndex); | |||
7062 | } | |||
7063 | } | |||
7064 | ||||
7065 | template <class ELFT> | |||
7066 | void LLVMELFDumper<ELFT>::printSymbolOtherField(const Elf_Sym &Symbol) const { | |||
7067 | std::vector<EnumEntry<unsigned>> SymOtherFlags = | |||
7068 | this->getOtherFlagsFromSymbol(this->Obj.getHeader(), Symbol); | |||
7069 | W.printFlags("Other", Symbol.st_other, ArrayRef(SymOtherFlags), 0x3u); | |||
7070 | } | |||
7071 | ||||
7072 | template <class ELFT> | |||
7073 | void LLVMELFDumper<ELFT>::printZeroSymbolOtherField( | |||
7074 | const Elf_Sym &Symbol) const { | |||
7075 | assert(Symbol.st_other == 0 && "non-zero Other Field")(static_cast <bool> (Symbol.st_other == 0 && "non-zero Other Field" ) ? void (0) : __assert_fail ("Symbol.st_other == 0 && \"non-zero Other Field\"" , "llvm/tools/llvm-readobj/ELFDumper.cpp", 7075, __extension__ __PRETTY_FUNCTION__)); | |||
7076 | // Usually st_other flag is zero. Do not pollute the output | |||
7077 | // by flags enumeration in that case. | |||
7078 | W.printNumber("Other", 0); | |||
7079 | } | |||
7080 | ||||
7081 | template <class ELFT> | |||
7082 | void LLVMELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex, | |||
7083 | DataRegion<Elf_Word> ShndxTable, | |||
7084 | std::optional<StringRef> StrTable, | |||
7085 | bool IsDynamic, | |||
7086 | bool /*NonVisibilityBitsUsed*/) const { | |||
7087 | std::string FullSymbolName = this->getFullSymbolName( | |||
7088 | Symbol, SymIndex, ShndxTable, StrTable, IsDynamic); | |||
7089 | unsigned char SymbolType = Symbol.getType(); | |||
7090 | ||||
7091 | DictScope D(W, "Symbol"); | |||
7092 | W.printNumber("Name", FullSymbolName, Symbol.st_name); | |||
7093 | W.printHex("Value", Symbol.st_value); | |||
7094 | W.printNumber("Size", Symbol.st_size); | |||
7095 | W.printEnum("Binding", Symbol.getBinding(), ArrayRef(ElfSymbolBindings)); | |||
7096 | if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && | |||
7097 | SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) | |||
7098 | W.printEnum("Type", SymbolType, ArrayRef(AMDGPUSymbolTypes)); | |||
7099 | else | |||
7100 | W.printEnum("Type", SymbolType, ArrayRef(ElfSymbolTypes)); | |||
7101 | if (Symbol.st_other == 0) | |||
7102 | printZeroSymbolOtherField(Symbol); | |||
7103 | else | |||
7104 | printSymbolOtherField(Symbol); | |||
7105 | printSymbolSection(Symbol, SymIndex, ShndxTable); | |||
7106 | } | |||
7107 | ||||
7108 | template <class ELFT> | |||
7109 | void LLVMELFDumper<ELFT>::printSymbols(bool PrintSymbols, | |||
7110 | bool PrintDynamicSymbols) { | |||
7111 | if (PrintSymbols) { | |||
7112 | ListScope Group(W, "Symbols"); | |||
7113 | this->printSymbolsHelper(false); | |||
7114 | } | |||
7115 | if (PrintDynamicSymbols) { | |||
7116 | ListScope Group(W, "DynamicSymbols"); | |||
7117 | this->printSymbolsHelper(true); | |||
7118 | } | |||
7119 | } | |||
7120 | ||||
7121 | template <class ELFT> void LLVMELFDumper<ELFT>::printDynamicTable() { | |||
7122 | Elf_Dyn_Range Table = this->dynamic_table(); | |||
7123 | if (Table.empty()) | |||
7124 | return; | |||
7125 | ||||
7126 | W.startLine() << "DynamicSection [ (" << Table.size() << " entries)\n"; | |||
7127 | ||||
7128 | size_t MaxTagSize = getMaxDynamicTagSize(this->Obj, Table); | |||
7129 | // The "Name/Value" column should be indented from the "Type" column by N | |||
7130 | // spaces, where N = MaxTagSize - length of "Type" (4) + trailing | |||
7131 | // space (1) = -3. | |||
7132 | W.startLine() << " Tag" << std::string(ELFT::Is64Bits ? 16 : 8, ' ') | |||
7133 | << "Type" << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; | |||
7134 | ||||
7135 | std::string ValueFmt = "%-" + std::to_string(MaxTagSize) + "s "; | |||
7136 | for (auto Entry : Table) { | |||
7137 | uintX_t Tag = Entry.getTag(); | |||
7138 | std::string Value = this->getDynamicEntry(Tag, Entry.getVal()); | |||
7139 | W.startLine() << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10, true) | |||
7140 | << " " | |||
7141 | << format(ValueFmt.c_str(), | |||
7142 | this->Obj.getDynamicTagAsString(Tag).c_str()) | |||
7143 | << Value << "\n"; | |||
7144 | } | |||
7145 | W.startLine() << "]\n"; | |||
7146 | } | |||
7147 | ||||
7148 | template <class ELFT> void LLVMELFDumper<ELFT>::printDynamicRelocations() { | |||
7149 | W.startLine() << "Dynamic Relocations {\n"; | |||
7150 | W.indent(); | |||
7151 | this->printDynamicRelocationsHelper(); | |||
7152 | W.unindent(); | |||
7153 | W.startLine() << "}\n"; | |||
7154 | } | |||
7155 | ||||
7156 | template <class ELFT> | |||
7157 | void LLVMELFDumper<ELFT>::printProgramHeaders( | |||
7158 | bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { | |||
7159 | if (PrintProgramHeaders) | |||
7160 | printProgramHeaders(); | |||
7161 | if (PrintSectionMapping == cl::BOU_TRUE) | |||
7162 | printSectionMapping(); | |||
7163 | } | |||
7164 | ||||
7165 | template <class ELFT> void LLVMELFDumper<ELFT>::printProgramHeaders() { | |||
7166 | ListScope L(W, "ProgramHeaders"); | |||
7167 | ||||
7168 | Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = this->Obj.program_headers(); | |||
7169 | if (!PhdrsOrErr) { | |||
7170 | this->reportUniqueWarning("unable to dump program headers: " + | |||
7171 | toString(PhdrsOrErr.takeError())); | |||
7172 | return; | |||
7173 | } | |||
7174 | ||||
7175 | for (const Elf_Phdr &Phdr : *PhdrsOrErr) { | |||
7176 | DictScope P(W, "ProgramHeader"); | |||
7177 | StringRef Type = | |||
7178 | segmentTypeToString(this->Obj.getHeader().e_machine, Phdr.p_type); | |||
7179 | ||||
7180 | W.printHex("Type", Type.empty() ? "Unknown" : Type, Phdr.p_type); | |||
7181 | W.printHex("Offset", Phdr.p_offset); | |||
7182 | W.printHex("VirtualAddress", Phdr.p_vaddr); | |||
7183 | W.printHex("PhysicalAddress", Phdr.p_paddr); | |||
7184 | W.printNumber("FileSize", Phdr.p_filesz); | |||
7185 | W.printNumber("MemSize", Phdr.p_memsz); | |||
7186 | W.printFlags("Flags", Phdr.p_flags, ArrayRef(ElfSegmentFlags)); | |||
7187 | W.printNumber("Alignment", Phdr.p_align); | |||
7188 | } | |||
7189 | } | |||
7190 | ||||
7191 | template <class ELFT> | |||
7192 | void LLVMELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) { | |||
7193 | ListScope SS(W, "VersionSymbols"); | |||
7194 | if (!Sec) | |||
7195 | return; | |||
7196 | ||||
7197 | StringRef StrTable; | |||
7198 | ArrayRef<Elf_Sym> Syms; | |||
7199 | const Elf_Shdr *SymTabSec; | |||
7200 | Expected<ArrayRef<Elf_Versym>> VerTableOrErr = | |||
7201 | this->getVersionTable(*Sec, &Syms, &StrTable, &SymTabSec); | |||
7202 | if (!VerTableOrErr) { | |||
7203 | this->reportUniqueWarning(VerTableOrErr.takeError()); | |||
7204 | return; | |||
7205 | } | |||
7206 | ||||
7207 | if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size()) | |||
7208 | return; | |||
7209 | ||||
7210 | ArrayRef<Elf_Word> ShNdxTable = this->getShndxTable(SymTabSec); | |||
7211 | for (size_t I = 0, E = Syms.size(); I < E; ++I) { | |||
7212 | DictScope S(W, "Symbol"); | |||
7213 | W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION); | |||
7214 | W.printString("Name", | |||
7215 | this->getFullSymbolName(Syms[I], I, ShNdxTable, StrTable, | |||
7216 | /*IsDynamic=*/true)); | |||
7217 | } | |||
7218 | } | |||
7219 | ||||
7220 | const EnumEntry<unsigned> SymVersionFlags[] = { | |||
7221 | {"Base", "BASE", VER_FLG_BASE}, | |||
7222 | {"Weak", "WEAK", VER_FLG_WEAK}, | |||
7223 | {"Info", "INFO", VER_FLG_INFO}}; | |||
7224 | ||||
7225 | template <class ELFT> | |||
7226 | void LLVMELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) { | |||
7227 | ListScope SD(W, "VersionDefinitions"); | |||
7228 | if (!Sec) | |||
7229 | return; | |||
7230 | ||||
7231 | Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec); | |||
7232 | if (!V) { | |||
7233 | this->reportUniqueWarning(V.takeError()); | |||
7234 | return; | |||
7235 | } | |||
7236 | ||||
7237 | for (const VerDef &D : *V) { | |||
7238 | DictScope Def(W, "Definition"); | |||
7239 | W.printNumber("Version", D.Version); | |||
7240 | W.printFlags("Flags", D.Flags, ArrayRef(SymVersionFlags)); | |||
7241 | W.printNumber("Index", D.Ndx); | |||
7242 | W.printNumber("Hash", D.Hash); | |||
7243 | W.printString("Name", D.Name.c_str()); | |||
7244 | W.printList( | |||
7245 | "Predecessors", D.AuxV, | |||
7246 | [](raw_ostream &OS, const VerdAux &Aux) { OS << Aux.Name.c_str(); }); | |||
7247 | } | |||
7248 | } | |||
7249 | ||||
7250 | template <class ELFT> | |||
7251 | void LLVMELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) { | |||
7252 | ListScope SD(W, "VersionRequirements"); | |||
7253 | if (!Sec) | |||
7254 | return; | |||
7255 | ||||
7256 | Expected<std::vector<VerNeed>> V = | |||
7257 | this->Obj.getVersionDependencies(*Sec, this->WarningHandler); | |||
7258 | if (!V) { | |||
7259 | this->reportUniqueWarning(V.takeError()); | |||
7260 | return; | |||
7261 | } | |||
7262 | ||||
7263 | for (const VerNeed &VN : *V) { | |||
7264 | DictScope Entry(W, "Dependency"); | |||
7265 | W.printNumber("Version", VN.Version); | |||
7266 | W.printNumber("Count", VN.Cnt); | |||
7267 | W.printString("FileName", VN.File.c_str()); | |||
7268 | ||||
7269 | ListScope L(W, "Entries"); | |||
7270 | for (const VernAux &Aux : VN.AuxV) { | |||
7271 | DictScope Entry(W, "Entry"); | |||
7272 | W.printNumber("Hash", Aux.Hash); | |||
7273 | W.printFlags("Flags", Aux.Flags, ArrayRef(SymVersionFlags)); | |||
7274 | W.printNumber("Index", Aux.Other); | |||
7275 | W.printString("Name", Aux.Name.c_str()); | |||
7276 | } | |||
7277 | } | |||
7278 | } | |||
7279 | ||||
7280 | template <class ELFT> | |||
7281 | void LLVMELFDumper<ELFT>::printHashHistogramStats(size_t NBucket, | |||
7282 | size_t MaxChain, | |||
7283 | size_t TotalSyms, | |||
7284 | ArrayRef<size_t> Count, | |||
7285 | bool IsGnu) const { | |||
7286 | StringRef HistName = IsGnu ? "GnuHashHistogram" : "HashHistogram"; | |||
7287 | StringRef BucketName = IsGnu ? "Bucket" : "Chain"; | |||
7288 | StringRef ListName = IsGnu ? "Buckets" : "Chains"; | |||
7289 | DictScope Outer(W, HistName); | |||
7290 | W.printNumber("TotalBuckets", NBucket); | |||
7291 | ListScope Buckets(W, ListName); | |||
7292 | size_t CumulativeNonZero = 0; | |||
7293 | for (size_t I = 0; I < MaxChain; ++I) { | |||
7294 | CumulativeNonZero += Count[I] * I; | |||
7295 | DictScope Bucket(W, BucketName); | |||
7296 | W.printNumber("Length", I); | |||
7297 | W.printNumber("Count", Count[I]); | |||
7298 | W.printNumber("Percentage", (float)(Count[I] * 100.0) / NBucket); | |||
7299 | W.printNumber("Coverage", (float)(CumulativeNonZero * 100.0) / TotalSyms); | |||
7300 | } | |||
7301 | } | |||
7302 | ||||
7303 | // Returns true if rel/rela section exists, and populates SymbolIndices. | |||
7304 | // Otherwise returns false. | |||
7305 | template <class ELFT> | |||
7306 | static bool getSymbolIndices(const typename ELFT::Shdr *CGRelSection, | |||
7307 | const ELFFile<ELFT> &Obj, | |||
7308 | const LLVMELFDumper<ELFT> *Dumper, | |||
7309 | SmallVector<uint32_t, 128> &SymbolIndices) { | |||
7310 | if (!CGRelSection) { | |||
7311 | Dumper->reportUniqueWarning( | |||
7312 | "relocation section for a call graph section doesn't exist"); | |||
7313 | return false; | |||
7314 | } | |||
7315 | ||||
7316 | if (CGRelSection->sh_type == SHT_REL) { | |||
7317 | typename ELFT::RelRange CGProfileRel; | |||
7318 | Expected<typename ELFT::RelRange> CGProfileRelOrError = | |||
7319 | Obj.rels(*CGRelSection); | |||
7320 | if (!CGProfileRelOrError) { | |||
7321 | Dumper->reportUniqueWarning("unable to load relocations for " | |||
7322 | "SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7323 | toString(CGProfileRelOrError.takeError())); | |||
7324 | return false; | |||
7325 | } | |||
7326 | ||||
7327 | CGProfileRel = *CGProfileRelOrError; | |||
7328 | for (const typename ELFT::Rel &Rel : CGProfileRel) | |||
7329 | SymbolIndices.push_back(Rel.getSymbol(Obj.isMips64EL())); | |||
7330 | } else { | |||
7331 | // MC unconditionally produces SHT_REL, but GNU strip/objcopy may convert | |||
7332 | // the format to SHT_RELA | |||
7333 | // (https://sourceware.org/bugzilla/show_bug.cgi?id=28035) | |||
7334 | typename ELFT::RelaRange CGProfileRela; | |||
7335 | Expected<typename ELFT::RelaRange> CGProfileRelaOrError = | |||
7336 | Obj.relas(*CGRelSection); | |||
7337 | if (!CGProfileRelaOrError) { | |||
7338 | Dumper->reportUniqueWarning("unable to load relocations for " | |||
7339 | "SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7340 | toString(CGProfileRelaOrError.takeError())); | |||
7341 | return false; | |||
7342 | } | |||
7343 | ||||
7344 | CGProfileRela = *CGProfileRelaOrError; | |||
7345 | for (const typename ELFT::Rela &Rela : CGProfileRela) | |||
7346 | SymbolIndices.push_back(Rela.getSymbol(Obj.isMips64EL())); | |||
7347 | } | |||
7348 | ||||
7349 | return true; | |||
7350 | } | |||
7351 | ||||
7352 | template <class ELFT> void LLVMELFDumper<ELFT>::printCGProfile() { | |||
7353 | auto IsMatch = [](const Elf_Shdr &Sec) -> bool { | |||
7354 | return Sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE; | |||
7355 | }; | |||
7356 | ||||
7357 | Expected<MapVector<const Elf_Shdr *, const Elf_Shdr *>> SecToRelocMapOrErr = | |||
7358 | this->Obj.getSectionAndRelocations(IsMatch); | |||
7359 | if (!SecToRelocMapOrErr) { | |||
7360 | this->reportUniqueWarning("unable to get CG Profile section(s): " + | |||
7361 | toString(SecToRelocMapOrErr.takeError())); | |||
7362 | return; | |||
7363 | } | |||
7364 | ||||
7365 | for (const auto &CGMapEntry : *SecToRelocMapOrErr) { | |||
7366 | const Elf_Shdr *CGSection = CGMapEntry.first; | |||
7367 | const Elf_Shdr *CGRelSection = CGMapEntry.second; | |||
7368 | ||||
7369 | Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr = | |||
7370 | this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(*CGSection); | |||
7371 | if (!CGProfileOrErr) { | |||
7372 | this->reportUniqueWarning( | |||
7373 | "unable to load the SHT_LLVM_CALL_GRAPH_PROFILE section: " + | |||
7374 | toString(CGProfileOrErr.takeError())); | |||
7375 | return; | |||
7376 | } | |||
7377 | ||||
7378 | SmallVector<uint32_t, 128> SymbolIndices; | |||
7379 | bool UseReloc = | |||
7380 | getSymbolIndices<ELFT>(CGRelSection, this->Obj, this, SymbolIndices); | |||
7381 | if (UseReloc && SymbolIndices.size() != CGProfileOrErr->size() * 2) { | |||
7382 | this->reportUniqueWarning( | |||
7383 | "number of from/to pairs does not match number of frequencies"); | |||
7384 | UseReloc = false; | |||
7385 | } | |||
7386 | ||||
7387 | ListScope L(W, "CGProfile"); | |||
7388 | for (uint32_t I = 0, Size = CGProfileOrErr->size(); I != Size; ++I) { | |||
7389 | const Elf_CGProfile &CGPE = (*CGProfileOrErr)[I]; | |||
7390 | DictScope D(W, "CGProfileEntry"); | |||
7391 | if (UseReloc) { | |||
7392 | uint32_t From = SymbolIndices[I * 2]; | |||
7393 | uint32_t To = SymbolIndices[I * 2 + 1]; | |||
7394 | W.printNumber("From", this->getStaticSymbolName(From), From); | |||
7395 | W.printNumber("To", this->getStaticSymbolName(To), To); | |||
7396 | } | |||
7397 | W.printNumber("Weight", CGPE.cgp_weight); | |||
7398 | } | |||
7399 | } | |||
7400 | } | |||
7401 | ||||
7402 | template <class ELFT> void LLVMELFDumper<ELFT>::printBBAddrMaps() { | |||
7403 | bool IsRelocatable = this->Obj.getHeader().e_type == ELF::ET_REL; | |||
7404 | using Elf_Shdr = typename ELFT::Shdr; | |||
7405 | auto IsMatch = [](const Elf_Shdr &Sec) -> bool { | |||
7406 | return Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP || | |||
7407 | Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP_V0; | |||
7408 | }; | |||
7409 | Expected<MapVector<const Elf_Shdr *, const Elf_Shdr *>> SecRelocMapOrErr = | |||
7410 | this->Obj.getSectionAndRelocations(IsMatch); | |||
7411 | if (!SecRelocMapOrErr) { | |||
7412 | this->reportUniqueWarning( | |||
7413 | "failed to get SHT_LLVM_BB_ADDR_MAP section(s): " + | |||
7414 | toString(SecRelocMapOrErr.takeError())); | |||
7415 | return; | |||
7416 | } | |||
7417 | for (auto const &[Sec, RelocSec] : *SecRelocMapOrErr) { | |||
7418 | std::optional<const Elf_Shdr *> FunctionSec; | |||
7419 | if (IsRelocatable) | |||
7420 | FunctionSec = | |||
7421 | unwrapOrError(this->FileName, this->Obj.getSection(Sec->sh_link)); | |||
7422 | ListScope L(W, "BBAddrMap"); | |||
7423 | if (IsRelocatable && !RelocSec) { | |||
7424 | this->reportUniqueWarning("unable to get relocation section for " + | |||
7425 | this->describe(*Sec)); | |||
7426 | continue; | |||
7427 | } | |||
7428 | Expected<std::vector<BBAddrMap>> BBAddrMapOrErr = | |||
7429 | this->Obj.decodeBBAddrMap(*Sec, RelocSec); | |||
7430 | if (!BBAddrMapOrErr) { | |||
7431 | this->reportUniqueWarning("unable to dump " + this->describe(*Sec) + | |||
7432 | ": " + toString(BBAddrMapOrErr.takeError())); | |||
7433 | continue; | |||
7434 | } | |||
7435 | for (const BBAddrMap &AM : *BBAddrMapOrErr) { | |||
7436 | DictScope D(W, "Function"); | |||
7437 | W.printHex("At", AM.Addr); | |||
7438 | SmallVector<uint32_t> FuncSymIndex = | |||
7439 | this->getSymbolIndexesForFunctionAddress(AM.Addr, FunctionSec); | |||
7440 | std::string FuncName = "<?>"; | |||
7441 | if (FuncSymIndex.empty()) | |||
7442 | this->reportUniqueWarning( | |||
7443 | "could not identify function symbol for address (0x" + | |||
7444 | Twine::utohexstr(AM.Addr) + ") in " + this->describe(*Sec)); | |||
7445 | else | |||
7446 | FuncName = this->getStaticSymbolName(FuncSymIndex.front()); | |||
7447 | W.printString("Name", FuncName); | |||
7448 | ||||
7449 | ListScope L(W, "BB entries"); | |||
7450 | for (const BBAddrMap::BBEntry &BBE : AM.BBEntries) { | |||
7451 | DictScope L(W); | |||
7452 | W.printNumber("ID", BBE.ID); | |||
7453 | W.printHex("Offset", BBE.Offset); | |||
7454 | W.printHex("Size", BBE.Size); | |||
7455 | W.printBoolean("HasReturn", BBE.hasReturn()); | |||
7456 | W.printBoolean("HasTailCall", BBE.hasTailCall()); | |||
7457 | W.printBoolean("IsEHPad", BBE.isEHPad()); | |||
7458 | W.printBoolean("CanFallThrough", BBE.canFallThrough()); | |||
7459 | } | |||
7460 | } | |||
7461 | } | |||
7462 | } | |||
7463 | ||||
7464 | template <class ELFT> void LLVMELFDumper<ELFT>::printAddrsig() { | |||
7465 | ListScope L(W, "Addrsig"); | |||
7466 | if (!this->DotAddrsigSec) | |||
7467 | return; | |||
7468 | ||||
7469 | Expected<std::vector<uint64_t>> SymsOrErr = | |||
7470 | decodeAddrsigSection(this->Obj, *this->DotAddrsigSec); | |||
7471 | if (!SymsOrErr) { | |||
7472 | this->reportUniqueWarning(SymsOrErr.takeError()); | |||
7473 | return; | |||
7474 | } | |||
7475 | ||||
7476 | for (uint64_t Sym : *SymsOrErr) | |||
7477 | W.printNumber("Sym", this->getStaticSymbolName(Sym), Sym); | |||
7478 | } | |||
7479 | ||||
7480 | template <typename ELFT> | |||
7481 | static bool printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc, | |||
7482 | ScopedPrinter &W) { | |||
7483 | // Return true if we were able to pretty-print the note, false otherwise. | |||
7484 | switch (NoteType) { | |||
7485 | default: | |||
7486 | return false; | |||
7487 | case ELF::NT_GNU_ABI_TAG: { | |||
7488 | const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); | |||
7489 | if (!AbiTag.IsValid) { | |||
7490 | W.printString("ABI", "<corrupt GNU_ABI_TAG>"); | |||
7491 | return false; | |||
7492 | } else { | |||
7493 | W.printString("OS", AbiTag.OSName); | |||
7494 | W.printString("ABI", AbiTag.ABI); | |||
7495 | } | |||
7496 | break; | |||
7497 | } | |||
7498 | case ELF::NT_GNU_BUILD_ID: { | |||
7499 | W.printString("Build ID", getGNUBuildId(Desc)); | |||
7500 | break; | |||
7501 | } | |||
7502 | case ELF::NT_GNU_GOLD_VERSION: | |||
7503 | W.printString("Version", getDescAsStringRef(Desc)); | |||
7504 | break; | |||
7505 | case ELF::NT_GNU_PROPERTY_TYPE_0: | |||
7506 | ListScope D(W, "Property"); | |||
7507 | for (const std::string &Property : getGNUPropertyList<ELFT>(Desc)) | |||
7508 | W.printString(Property); | |||
7509 | break; | |||
7510 | } | |||
7511 | return true; | |||
7512 | } | |||
7513 | ||||
7514 | static bool printAndroidNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc, | |||
7515 | ScopedPrinter &W) { | |||
7516 | // Return true if we were able to pretty-print the note, false otherwise. | |||
7517 | AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc); | |||
7518 | if (Props.empty()) | |||
7519 | return false; | |||
7520 | for (const auto &KV : Props) | |||
7521 | W.printString(KV.first, KV.second); | |||
7522 | return true; | |||
7523 | } | |||
7524 | ||||
7525 | template <class ELFT> | |||
7526 | void LLVMELFDumper<ELFT>::printMemtag( | |||
7527 | const ArrayRef<std::pair<std::string, std::string>> DynamicEntries, | |||
7528 | const ArrayRef<uint8_t> AndroidNoteDesc, | |||
7529 | const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) { | |||
7530 | { | |||
7531 | ListScope L(W, "Memtag Dynamic Entries:"); | |||
7532 | if (DynamicEntries.empty()) | |||
7533 | W.printString("< none found >"); | |||
7534 | for (const auto &DynamicEntryKV : DynamicEntries) | |||
7535 | W.printString(DynamicEntryKV.first, DynamicEntryKV.second); | |||
7536 | } | |||
7537 | ||||
7538 | if (!AndroidNoteDesc.empty()) { | |||
7539 | ListScope L(W, "Memtag Android Note:"); | |||
7540 | printAndroidNoteLLVMStyle(ELF::NT_ANDROID_TYPE_MEMTAG, AndroidNoteDesc, W); | |||
7541 | } | |||
7542 | ||||
7543 | if (Descriptors.empty()) | |||
7544 | return; | |||
7545 | ||||
7546 | { | |||
7547 | ListScope L(W, "Memtag Global Descriptors:"); | |||
7548 | for (const auto &[Addr, BytesToTag] : Descriptors) { | |||
7549 | W.printHex("0x" + utohexstr(Addr), BytesToTag); | |||
7550 | } | |||
7551 | } | |||
7552 | } | |||
7553 | ||||
7554 | template <typename ELFT> | |||
7555 | static bool printLLVMOMPOFFLOADNoteLLVMStyle(uint32_t NoteType, | |||
7556 | ArrayRef<uint8_t> Desc, | |||
7557 | ScopedPrinter &W) { | |||
7558 | switch (NoteType) { | |||
7559 | default: | |||
7560 | return false; | |||
7561 | case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION: | |||
7562 | W.printString("Version", getDescAsStringRef(Desc)); | |||
7563 | break; | |||
7564 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER: | |||
7565 | W.printString("Producer", getDescAsStringRef(Desc)); | |||
7566 | break; | |||
7567 | case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION: | |||
7568 | W.printString("Producer version", getDescAsStringRef(Desc)); | |||
7569 | break; | |||
7570 | } | |||
7571 | return true; | |||
7572 | } | |||
7573 | ||||
7574 | static void printCoreNoteLLVMStyle(const CoreNote &Note, ScopedPrinter &W) { | |||
7575 | W.printNumber("Page Size", Note.PageSize); | |||
7576 | for (const CoreFileMapping &Mapping : Note.Mappings) { | |||
7577 | ListScope D(W, "Mapping"); | |||
7578 | W.printHex("Start", Mapping.Start); | |||
7579 | W.printHex("End", Mapping.End); | |||
7580 | W.printHex("Offset", Mapping.Offset); | |||
7581 | W.printString("Filename", Mapping.Filename); | |||
7582 | } | |||
7583 | } | |||
7584 | ||||
7585 | template <class ELFT> void LLVMELFDumper<ELFT>::printNotes() { | |||
7586 | ListScope L(W, "Notes"); | |||
7587 | ||||
7588 | std::unique_ptr<DictScope> NoteScope; | |||
7589 | auto StartNotes = [&](std::optional<StringRef> SecName, | |||
7590 | const typename ELFT::Off Offset, | |||
7591 | const typename ELFT::Addr Size) { | |||
7592 | NoteScope = std::make_unique<DictScope>(W, "NoteSection"); | |||
7593 | W.printString("Name", SecName ? *SecName : "<?>"); | |||
7594 | W.printHex("Offset", Offset); | |||
7595 | W.printHex("Size", Size); | |||
7596 | }; | |||
7597 | ||||
7598 | auto EndNotes = [&] { NoteScope.reset(); }; | |||
7599 | ||||
7600 | auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error { | |||
7601 | DictScope D2(W, "Note"); | |||
7602 | StringRef Name = Note.getName(); | |||
7603 | ArrayRef<uint8_t> Descriptor = Note.getDesc(); | |||
7604 | Elf_Word Type = Note.getType(); | |||
7605 | ||||
7606 | // Print the note owner/type. | |||
7607 | W.printString("Owner", Name); | |||
7608 | W.printHex("Data size", Descriptor.size()); | |||
7609 | ||||
7610 | StringRef NoteType = | |||
7611 | getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type); | |||
7612 | if (!NoteType.empty()) | |||
7613 | W.printString("Type", NoteType); | |||
7614 | else | |||
7615 | W.printString("Type", | |||
7616 | "Unknown (" + to_string(format_hex(Type, 10)) + ")"); | |||
7617 | ||||
7618 | // Print the description, or fallback to printing raw bytes for unknown | |||
7619 | // owners/if we fail to pretty-print the contents. | |||
7620 | if (Name == "GNU") { | |||
7621 | if (printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W)) | |||
7622 | return Error::success(); | |||
7623 | } else if (Name == "FreeBSD") { | |||
7624 | if (std::optional<FreeBSDNote> N = | |||
7625 | getFreeBSDNote<ELFT>(Type, Descriptor, IsCore)) { | |||
7626 | W.printString(N->Type, N->Value); | |||
7627 | return Error::success(); | |||
7628 | } | |||
7629 | } else if (Name == "AMD") { | |||
7630 | const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); | |||
7631 | if (!N.Type.empty()) { | |||
7632 | W.printString(N.Type, N.Value); | |||
7633 | return Error::success(); | |||
7634 | } | |||
7635 | } else if (Name == "AMDGPU") { | |||
7636 | const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); | |||
7637 | if (!N.Type.empty()) { | |||
7638 | W.printString(N.Type, N.Value); | |||
7639 | return Error::success(); | |||
7640 | } | |||
7641 | } else if (Name == "LLVMOMPOFFLOAD") { | |||
7642 | if (printLLVMOMPOFFLOADNoteLLVMStyle<ELFT>(Type, Descriptor, W)) | |||
7643 | return Error::success(); | |||
7644 | } else if (Name == "CORE") { | |||
7645 | if (Type == ELF::NT_FILE) { | |||
7646 | DataExtractor DescExtractor(Descriptor, | |||
7647 | ELFT::TargetEndianness == support::little, | |||
7648 | sizeof(Elf_Addr)); | |||
7649 | if (Expected<CoreNote> N = readCoreNote(DescExtractor)) { | |||
7650 | printCoreNoteLLVMStyle(*N, W); | |||
7651 | return Error::success(); | |||
7652 | } else { | |||
7653 | return N.takeError(); | |||
7654 | } | |||
7655 | } | |||
7656 | } else if (Name == "Android") { | |||
7657 | if (printAndroidNoteLLVMStyle(Type, Descriptor, W)) | |||
7658 | return Error::success(); | |||
7659 | } | |||
7660 | if (!Descriptor.empty()) { | |||
7661 | W.printBinaryBlock("Description data", Descriptor); | |||
7662 | } | |||
7663 | return Error::success(); | |||
7664 | }; | |||
7665 | ||||
7666 | processNotesHelper(*this, /*StartNotesFn=*/StartNotes, | |||
7667 | /*ProcessNoteFn=*/ProcessNote, /*FinishNotesFn=*/EndNotes); | |||
7668 | } | |||
7669 | ||||
7670 | template <class ELFT> void LLVMELFDumper<ELFT>::printELFLinkerOptions() { | |||
7671 | ListScope L(W, "LinkerOptions"); | |||
7672 | ||||
7673 | unsigned I = -1; | |||
7674 | for (const Elf_Shdr &Shdr : cantFail(this->Obj.sections())) { | |||
7675 | ++I; | |||
7676 | if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS) | |||
7677 | continue; | |||
7678 | ||||
7679 | Expected<ArrayRef<uint8_t>> ContentsOrErr = | |||
7680 | this->Obj.getSectionContents(Shdr); | |||
7681 | if (!ContentsOrErr) { | |||
7682 | this->reportUniqueWarning("unable to read the content of the " | |||
7683 | "SHT_LLVM_LINKER_OPTIONS section: " + | |||
7684 | toString(ContentsOrErr.takeError())); | |||
7685 | continue; | |||
7686 | } | |||
7687 | if (ContentsOrErr->empty()) | |||
7688 | continue; | |||
7689 | ||||
7690 | if (ContentsOrErr->back() != 0) { | |||
7691 | this->reportUniqueWarning("SHT_LLVM_LINKER_OPTIONS section at index " + | |||
7692 | Twine(I) + | |||
7693 | " is broken: the " | |||
7694 | "content is not null-terminated"); | |||
7695 | continue; | |||
7696 | } | |||
7697 | ||||
7698 | SmallVector<StringRef, 16> Strings; | |||
7699 | toStringRef(ContentsOrErr->drop_back()).split(Strings, '\0'); | |||
7700 | if (Strings.size() % 2 != 0) { | |||
7701 | this->reportUniqueWarning( | |||
7702 | "SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + | |||
7703 | " is broken: an incomplete " | |||
7704 | "key-value pair was found. The last possible key was: \"" + | |||
7705 | Strings.back() + "\""); | |||
7706 | continue; | |||
7707 | } | |||
7708 | ||||
7709 | for (size_t I = 0; I < Strings.size(); I += 2) | |||
7710 | W.printString(Strings[I], Strings[I + 1]); | |||
7711 | } | |||
7712 | } | |||
7713 | ||||
7714 | template <class ELFT> void LLVMELFDumper<ELFT>::printDependentLibs() { | |||
7715 | ListScope L(W, "DependentLibs"); | |||
7716 | this->printDependentLibsHelper( | |||
7717 | [](const Elf_Shdr &) {}, | |||
7718 | [this](StringRef Lib, uint64_t) { W.printString(Lib); }); | |||
7719 | } | |||
7720 | ||||
7721 | template <class ELFT> void LLVMELFDumper<ELFT>::printStackSizes() { | |||
7722 | ListScope L(W, "StackSizes"); | |||
7723 | if (this->Obj.getHeader().e_type == ELF::ET_REL) | |||
7724 | this->printRelocatableStackSizes([]() {}); | |||
7725 | else | |||
7726 | this->printNonRelocatableStackSizes([]() {}); | |||
7727 | } | |||
7728 | ||||
7729 | template <class ELFT> | |||
7730 | void LLVMELFDumper<ELFT>::printStackSizeEntry(uint64_t Size, | |||
7731 | ArrayRef<std::string> FuncNames) { | |||
7732 | DictScope D(W, "Entry"); | |||
7733 | W.printList("Functions", FuncNames); | |||
7734 | W.printHex("Size", Size); | |||
7735 | } | |||
7736 | ||||
7737 | template <class ELFT> | |||
7738 | void LLVMELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { | |||
7739 | auto PrintEntry = [&](const Elf_Addr *E) { | |||
7740 | W.printHex("Address", Parser.getGotAddress(E)); | |||
7741 | W.printNumber("Access", Parser.getGotOffset(E)); | |||
7742 | W.printHex("Initial", *E); | |||
7743 | }; | |||
7744 | ||||
7745 | DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT"); | |||
7746 | ||||
7747 | W.printHex("Canonical gp value", Parser.getGp()); | |||
7748 | { | |||
7749 | ListScope RS(W, "Reserved entries"); | |||
7750 | { | |||
7751 | DictScope D(W, "Entry"); | |||
7752 | PrintEntry(Parser.getGotLazyResolver()); | |||
7753 | W.printString("Purpose", StringRef("Lazy resolver")); | |||
7754 | } | |||
7755 | ||||
7756 | if (Parser.getGotModulePointer()) { | |||
7757 | DictScope D(W, "Entry"); | |||
7758 | PrintEntry(Parser.getGotModulePointer()); | |||
7759 | W.printString("Purpose", StringRef("Module pointer (GNU extension)")); | |||
7760 | } | |||
7761 | } | |||
7762 | { | |||
7763 | ListScope LS(W, "Local entries"); | |||
7764 | for (auto &E : Parser.getLocalEntries()) { | |||
7765 | DictScope D(W, "Entry"); | |||
7766 | PrintEntry(&E); | |||
7767 | } | |||
7768 | } | |||
7769 | ||||
7770 | if (Parser.IsStatic) | |||
7771 | return; | |||
7772 | ||||
7773 | { | |||
7774 | ListScope GS(W, "Global entries"); | |||
7775 | for (auto &E : Parser.getGlobalEntries()) { | |||
7776 | DictScope D(W, "Entry"); | |||
7777 | ||||
7778 | PrintEntry(&E); | |||
7779 | ||||
7780 | const Elf_Sym &Sym = *Parser.getGotSym(&E); | |||
7781 | W.printHex("Value", Sym.st_value); | |||
7782 | W.printEnum("Type", Sym.getType(), ArrayRef(ElfSymbolTypes)); | |||
7783 | ||||
7784 | const unsigned SymIndex = &Sym - this->dynamic_symbols().begin(); | |||
7785 | DataRegion<Elf_Word> ShndxTable( | |||
7786 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
7787 | printSymbolSection(Sym, SymIndex, ShndxTable); | |||
7788 | ||||
7789 | std::string SymName = this->getFullSymbolName( | |||
7790 | Sym, SymIndex, ShndxTable, this->DynamicStringTable, true); | |||
7791 | W.printNumber("Name", SymName, Sym.st_name); | |||
7792 | } | |||
7793 | } | |||
7794 | ||||
7795 | W.printNumber("Number of TLS and multi-GOT entries", | |||
7796 | uint64_t(Parser.getOtherEntries().size())); | |||
7797 | } | |||
7798 | ||||
7799 | template <class ELFT> | |||
7800 | void LLVMELFDumper<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { | |||
7801 | auto PrintEntry = [&](const Elf_Addr *E) { | |||
7802 | W.printHex("Address", Parser.getPltAddress(E)); | |||
7803 | W.printHex("Initial", *E); | |||
7804 | }; | |||
7805 | ||||
7806 | DictScope GS(W, "PLT GOT"); | |||
7807 | ||||
7808 | { | |||
7809 | ListScope RS(W, "Reserved entries"); | |||
7810 | { | |||
7811 | DictScope D(W, "Entry"); | |||
7812 | PrintEntry(Parser.getPltLazyResolver()); | |||
7813 | W.printString("Purpose", StringRef("PLT lazy resolver")); | |||
7814 | } | |||
7815 | ||||
7816 | if (auto E = Parser.getPltModulePointer()) { | |||
7817 | DictScope D(W, "Entry"); | |||
7818 | PrintEntry(E); | |||
7819 | W.printString("Purpose", StringRef("Module pointer")); | |||
7820 | } | |||
7821 | } | |||
7822 | { | |||
7823 | ListScope LS(W, "Entries"); | |||
7824 | DataRegion<Elf_Word> ShndxTable( | |||
7825 | (const Elf_Word *)this->DynSymTabShndxRegion.Addr, this->Obj.end()); | |||
7826 | for (auto &E : Parser.getPltEntries()) { | |||
7827 | DictScope D(W, "Entry"); | |||
7828 | PrintEntry(&E); | |||
7829 | ||||
7830 | const Elf_Sym &Sym = *Parser.getPltSym(&E); | |||
7831 | W.printHex("Value", Sym.st_value); | |||
7832 | W.printEnum("Type", Sym.getType(), ArrayRef(ElfSymbolTypes)); | |||
7833 | printSymbolSection(Sym, &Sym - this->dynamic_symbols().begin(), | |||
7834 | ShndxTable); | |||
7835 | ||||
7836 | const Elf_Sym *FirstSym = cantFail( | |||
7837 | this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0)); | |||
7838 | std::string SymName = this->getFullSymbolName( | |||
7839 | Sym, &Sym - FirstSym, ShndxTable, Parser.getPltStrTable(), true); | |||
7840 | W.printNumber("Name", SymName, Sym.st_name); | |||
7841 | } | |||
7842 | } | |||
7843 | } | |||
7844 | ||||
7845 | template <class ELFT> void LLVMELFDumper<ELFT>::printMipsABIFlags() { | |||
7846 | const Elf_Mips_ABIFlags<ELFT> *Flags; | |||
7847 | if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = | |||
7848 | getMipsAbiFlagsSection(*this)) { | |||
7849 | Flags = *SecOrErr; | |||
7850 | if (!Flags) { | |||
7851 | W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; | |||
7852 | return; | |||
7853 | } | |||
7854 | } else { | |||
7855 | this->reportUniqueWarning(SecOrErr.takeError()); | |||
7856 | return; | |||
7857 | } | |||
7858 | ||||
7859 | raw_ostream &OS = W.getOStream(); | |||
7860 | DictScope GS(W, "MIPS ABI Flags"); | |||
7861 | ||||
7862 | W.printNumber("Version", Flags->version); | |||
7863 | W.startLine() << "ISA: "; | |||
7864 | if (Flags->isa_rev <= 1) | |||
7865 | OS << format("MIPS%u", Flags->isa_level); | |||
7866 | else | |||
7867 | OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); | |||
7868 | OS << "\n"; | |||
7869 | W.printEnum("ISA Extension", Flags->isa_ext, ArrayRef(ElfMipsISAExtType)); | |||
7870 | W.printFlags("ASEs", Flags->ases, ArrayRef(ElfMipsASEFlags)); | |||
7871 | W.printEnum("FP ABI", Flags->fp_abi, ArrayRef(ElfMipsFpABIType)); | |||
7872 | W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); | |||
7873 | W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); | |||
7874 | W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); | |||
7875 | W.printFlags("Flags 1", Flags->flags1, ArrayRef(ElfMipsFlags1)); | |||
7876 | W.printHex("Flags 2", Flags->flags2); | |||
7877 | } | |||
7878 | ||||
7879 | template <class ELFT> | |||
7880 | void JSONELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj, | |||
7881 | ArrayRef<std::string> InputFilenames, | |||
7882 | const Archive *A) { | |||
7883 | FileScope = std::make_unique<DictScope>(this->W); | |||
7884 | DictScope D(this->W, "FileSummary"); | |||
7885 | this->W.printString("File", FileStr); | |||
7886 | this->W.printString("Format", Obj.getFileFormatName()); | |||
7887 | this->W.printString("Arch", Triple::getArchTypeName(Obj.getArch())); | |||
7888 | this->W.printString( | |||
7889 | "AddressSize", | |||
7890 | std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress()))); | |||
7891 | this->printLoadName(); | |||
7892 | } | |||
7893 | ||||
7894 | template <class ELFT> | |||
7895 | void JSONELFDumper<ELFT>::printZeroSymbolOtherField( | |||
7896 | const Elf_Sym &Symbol) const { | |||
7897 | // We want the JSON format to be uniform, since it is machine readable, so | |||
7898 | // always print the `Other` field the same way. | |||
7899 | this->printSymbolOtherField(Symbol); | |||
7900 | } | |||
7901 | ||||
7902 | template <class ELFT> | |||
7903 | void JSONELFDumper<ELFT>::printDefaultRelRelaReloc(const Relocation<ELFT> &R, | |||
7904 | StringRef SymbolName, | |||
7905 | StringRef RelocName) { | |||
7906 | this->printExpandedRelRelaReloc(R, SymbolName, RelocName); | |||
7907 | } | |||
7908 | ||||
7909 | template <class ELFT> | |||
7910 | void JSONELFDumper<ELFT>::printRelocationSectionInfo(const Elf_Shdr &Sec, | |||
7911 | StringRef Name, | |||
7912 | const unsigned SecNdx) { | |||
7913 | DictScope Group(this->W); | |||
7914 | this->W.printNumber("SectionIndex", SecNdx); | |||
7915 | ListScope D(this->W, "Relocs"); | |||
7916 | this->printRelocationsHelper(Sec); | |||
| ||||
7917 | } | |||
7918 | ||||
7919 | template <class ELFT> | |||
7920 | std::string JSONELFDumper<ELFT>::getGroupSectionHeaderName() const { | |||
7921 | return "GroupSections"; | |||
7922 | } | |||
7923 | ||||
7924 | template <class ELFT> | |||
7925 | void JSONELFDumper<ELFT>::printSectionGroupMembers(StringRef Name, | |||
7926 | uint64_t Idx) const { | |||
7927 | DictScope Grp(this->W); | |||
7928 | this->W.printString("Name", Name); | |||
7929 | this->W.printNumber("Index", Idx); | |||
7930 | } | |||
7931 | ||||
7932 | template <class ELFT> void JSONELFDumper<ELFT>::printEmptyGroupMessage() const { | |||
7933 | // JSON output does not need to print anything for empty groups | |||
7934 | } |