blob: f7fef8d1617dcde4f2261eae874bcf6ea9c5c028 [file] [log] [blame]
Eugene Zelenko416e0592017-06-09 21:41:54 +00001//===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
George Rimar47936762016-01-16 00:49:19 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
George Rimar47936762016-01-16 00:49:19 +00006//
7//===----------------------------------------------------------------------===//
8///
9/// \file
Adrian Prantl5f8f34e42018-05-01 15:54:18 +000010/// This file implements the ELF-specific dumper for llvm-readobj.
George Rimar47936762016-01-16 00:49:19 +000011///
12//===----------------------------------------------------------------------===//
13
George Rimar47936762016-01-16 00:49:19 +000014#include "ARMEHABIPrinter.h"
Rafael Auler86fb7bf2018-03-08 00:46:53 +000015#include "DwarfCFIEHPrinter.h"
George Rimar47936762016-01-16 00:49:19 +000016#include "Error.h"
17#include "ObjDumper.h"
18#include "StackMapPrinter.h"
Zachary Turner88bb1632016-05-03 00:28:04 +000019#include "llvm-readobj.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000020#include "llvm/ADT/ArrayRef.h"
George Rimar762abff62017-09-16 14:29:51 +000021#include "llvm/ADT/DenseMap.h"
George Rimar47936762016-01-16 00:49:19 +000022#include "llvm/ADT/Optional.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000023#include "llvm/ADT/PointerIntPair.h"
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +000024#include "llvm/ADT/STLExtras.h"
George Rimar47936762016-01-16 00:49:19 +000025#include "llvm/ADT/SmallString.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000026#include "llvm/ADT/SmallVector.h"
George Rimar47936762016-01-16 00:49:19 +000027#include "llvm/ADT/StringExtras.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000028#include "llvm/ADT/StringRef.h"
29#include "llvm/ADT/Twine.h"
Scott Linderf5b36e52018-12-12 19:39:27 +000030#include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000031#include "llvm/BinaryFormat/ELF.h"
James Hendersone50d9cb2019-01-17 15:34:12 +000032#include "llvm/Demangle/Demangle.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000033#include "llvm/Object/ELF.h"
George Rimar47936762016-01-16 00:49:19 +000034#include "llvm/Object/ELFObjectFile.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000035#include "llvm/Object/ELFTypes.h"
36#include "llvm/Object/Error.h"
37#include "llvm/Object/ObjectFile.h"
38#include "llvm/Object/StackMapParser.h"
Konstantin Zhuravlyovb3c605d2017-10-14 18:21:42 +000039#include "llvm/Support/AMDGPUMetadata.h"
Sam Parker34315ee2017-01-13 10:50:01 +000040#include "llvm/Support/ARMAttributeParser.h"
George Rimar47936762016-01-16 00:49:19 +000041#include "llvm/Support/ARMBuildAttributes.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000042#include "llvm/Support/Casting.h"
George Rimar47936762016-01-16 00:49:19 +000043#include "llvm/Support/Compiler.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000044#include "llvm/Support/Endian.h"
45#include "llvm/Support/ErrorHandling.h"
George Rimar47936762016-01-16 00:49:19 +000046#include "llvm/Support/Format.h"
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +000047#include "llvm/Support/FormatVariadic.h"
Zachary Turner88bb1632016-05-03 00:28:04 +000048#include "llvm/Support/FormattedStream.h"
Peter Collingbourne3e227332018-07-17 22:17:18 +000049#include "llvm/Support/LEB128.h"
George Rimar47936762016-01-16 00:49:19 +000050#include "llvm/Support/MathExtras.h"
51#include "llvm/Support/MipsABIFlags.h"
Zachary Turner88bb1632016-05-03 00:28:04 +000052#include "llvm/Support/ScopedPrinter.h"
George Rimar47936762016-01-16 00:49:19 +000053#include "llvm/Support/raw_ostream.h"
Eugene Zelenko416e0592017-06-09 21:41:54 +000054#include <algorithm>
55#include <cinttypes>
56#include <cstddef>
57#include <cstdint>
58#include <cstdlib>
59#include <iterator>
60#include <memory>
61#include <string>
62#include <system_error>
63#include <vector>
George Rimar47936762016-01-16 00:49:19 +000064
65using namespace llvm;
66using namespace llvm::object;
67using namespace ELF;
68
69#define LLVM_READOBJ_ENUM_CASE(ns, enum) \
70 case ns::enum: return #enum;
71
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +000072#define ENUM_ENT(enum, altName) \
73 { #enum, altName, ELF::enum }
74
75#define ENUM_ENT_1(enum) \
76 { #enum, #enum, ELF::enum }
77
Hemant Kulkarni7d564ba2016-03-28 17:20:23 +000078#define LLVM_READOBJ_PHDR_ENUM(ns, enum) \
79 case ns::enum: \
80 return std::string(#enum).substr(3);
81
Hemant Kulkarni206ba842016-03-09 19:16:13 +000082#define TYPEDEF_ELF_TYPES(ELFT) \
Eugene Zelenko416e0592017-06-09 21:41:54 +000083 using ELFO = ELFFile<ELFT>; \
Rui Ueyama478d6352018-01-12 02:28:31 +000084 using Elf_Addr = typename ELFT::Addr; \
85 using Elf_Shdr = typename ELFT::Shdr; \
86 using Elf_Sym = typename ELFT::Sym; \
87 using Elf_Dyn = typename ELFT::Dyn; \
88 using Elf_Dyn_Range = typename ELFT::DynRange; \
89 using Elf_Rel = typename ELFT::Rel; \
90 using Elf_Rela = typename ELFT::Rela; \
Jake Ehrlich0f440d82018-06-28 21:07:34 +000091 using Elf_Relr = typename ELFT::Relr; \
Rui Ueyama478d6352018-01-12 02:28:31 +000092 using Elf_Rel_Range = typename ELFT::RelRange; \
93 using Elf_Rela_Range = typename ELFT::RelaRange; \
Jake Ehrlich0f440d82018-06-28 21:07:34 +000094 using Elf_Relr_Range = typename ELFT::RelrRange; \
Rui Ueyama478d6352018-01-12 02:28:31 +000095 using Elf_Phdr = typename ELFT::Phdr; \
96 using Elf_Half = typename ELFT::Half; \
97 using Elf_Ehdr = typename ELFT::Ehdr; \
98 using Elf_Word = typename ELFT::Word; \
99 using Elf_Hash = typename ELFT::Hash; \
100 using Elf_GnuHash = typename ELFT::GnuHash; \
Scott Linder77a5f212018-03-12 19:28:50 +0000101 using Elf_Note = typename ELFT::Note; \
Rui Ueyama478d6352018-01-12 02:28:31 +0000102 using Elf_Sym_Range = typename ELFT::SymRange; \
103 using Elf_Versym = typename ELFT::Versym; \
104 using Elf_Verneed = typename ELFT::Verneed; \
105 using Elf_Vernaux = typename ELFT::Vernaux; \
106 using Elf_Verdef = typename ELFT::Verdef; \
107 using Elf_Verdaux = typename ELFT::Verdaux; \
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000108 using Elf_CGProfile = typename ELFT::CGProfile; \
Rui Ueyama478d6352018-01-12 02:28:31 +0000109 using uintX_t = typename ELFT::uint;
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000110
George Rimar47936762016-01-16 00:49:19 +0000111namespace {
112
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000113template <class ELFT> class DumpStyle;
114
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000115/// Represents a contiguous uniform range in the file. We cannot just create a
116/// range directly because when creating one of these from the .dynamic table
117/// the size, entity size and virtual address are different entries in arbitrary
118/// order (DT_REL, DT_RELSZ, DT_RELENT for example).
Rafael Espindola65a6fd82016-02-16 14:27:33 +0000119struct DynRegionInfo {
Eugene Zelenko416e0592017-06-09 21:41:54 +0000120 DynRegionInfo() = default;
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000121 DynRegionInfo(const void *A, uint64_t S, uint64_t ES)
122 : Addr(A), Size(S), EntSize(ES) {}
Eugene Zelenko416e0592017-06-09 21:41:54 +0000123
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000124 /// Address in current address space.
Eugene Zelenko416e0592017-06-09 21:41:54 +0000125 const void *Addr = nullptr;
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000126 /// Size in bytes of the region.
Eugene Zelenko416e0592017-06-09 21:41:54 +0000127 uint64_t Size = 0;
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000128 /// Size of each entity in the region.
Eugene Zelenko416e0592017-06-09 21:41:54 +0000129 uint64_t EntSize = 0;
Rafael Espindolac70aeda2016-02-16 14:50:39 +0000130
Rafael Espindolaaafcf752016-04-05 14:47:22 +0000131 template <typename Type> ArrayRef<Type> getAsArrayRef() const {
Rafael Espindolac70aeda2016-02-16 14:50:39 +0000132 const Type *Start = reinterpret_cast<const Type *>(Addr);
Rafael Espindola944f6552016-02-16 15:16:00 +0000133 if (!Start)
134 return {Start, Start};
Rafael Espindolac70aeda2016-02-16 14:50:39 +0000135 if (EntSize != sizeof(Type) || Size % EntSize)
136 reportError("Invalid entity size");
137 return {Start, Start + (Size / EntSize)};
138 }
Rafael Espindola65a6fd82016-02-16 14:27:33 +0000139};
140
George Rimar47936762016-01-16 00:49:19 +0000141template<typename ELFT>
142class ELFDumper : public ObjDumper {
143public:
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000144 ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, ScopedPrinter &Writer);
George Rimar47936762016-01-16 00:49:19 +0000145
146 void printFileHeaders() override;
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +0000147 void printSectionHeaders() override;
George Rimar47936762016-01-16 00:49:19 +0000148 void printRelocations() override;
149 void printDynamicRelocations() override;
150 void printSymbols() override;
151 void printDynamicSymbols() override;
152 void printUnwindInfo() override;
153
154 void printDynamicTable() override;
155 void printNeededLibraries() override;
156 void printProgramHeaders() override;
157 void printHashTable() override;
158 void printGnuHashTable() override;
159 void printLoadName() override;
160 void printVersionInfo() override;
Hemant Kulkarniab4a46f2016-01-26 19:46:39 +0000161 void printGroupSections() override;
George Rimar47936762016-01-16 00:49:19 +0000162
163 void printAttributes() override;
164 void printMipsPLTGOT() override;
165 void printMipsABIFlags() override;
166 void printMipsReginfo() override;
Simon Atanasyan8a71b532016-05-04 05:58:57 +0000167 void printMipsOptions() override;
George Rimar47936762016-01-16 00:49:19 +0000168
169 void printStackMap() const override;
170
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +0000171 void printHashHistogram() override;
172
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000173 void printCGProfile() override;
Peter Collingbourne3e227332018-07-17 22:17:18 +0000174 void printAddrsig() override;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000175
Saleem Abdulrasool6a405442016-08-30 18:52:02 +0000176 void printNotes() override;
177
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +0000178 void printELFLinkerOptions() override;
179
George Rimar47936762016-01-16 00:49:19 +0000180private:
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000181 std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
Eugene Zelenko416e0592017-06-09 21:41:54 +0000182
Rafael Espindola6bc29902016-10-06 14:07:26 +0000183 TYPEDEF_ELF_TYPES(ELFT)
George Rimar47936762016-01-16 00:49:19 +0000184
Rafael Espindolae17c3f32016-02-17 16:48:00 +0000185 DynRegionInfo checkDRI(DynRegionInfo DRI) {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000186 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Rafael Espindolae17c3f32016-02-17 16:48:00 +0000187 if (DRI.Addr < Obj->base() ||
188 (const uint8_t *)DRI.Addr + DRI.Size > Obj->base() + Obj->getBufSize())
189 error(llvm::object::object_error::parse_failed);
190 return DRI;
191 }
192
193 DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000194 return checkDRI({ObjF->getELFFile()->base() + P->p_offset, P->p_filesz, EntSize});
Rafael Espindolae17c3f32016-02-17 16:48:00 +0000195 }
196
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000197 DynRegionInfo createDRIFrom(const Elf_Shdr *S) {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000198 return checkDRI({ObjF->getELFFile()->base() + S->sh_offset, S->sh_size, S->sh_entsize});
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000199 }
200
Michael J. Spencer60d82b22016-02-11 04:59:37 +0000201 void parseDynamicTable(ArrayRef<const Elf_Phdr *> LoadSegments);
202
George Rimar47936762016-01-16 00:49:19 +0000203 void printValue(uint64_t Type, uint64_t Value);
204
George Rimar47936762016-01-16 00:49:19 +0000205 StringRef getDynamicString(uint64_t Offset) const;
George Rimar47936762016-01-16 00:49:19 +0000206 StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000207 bool &IsDefault) const;
208 void LoadVersionMap() const;
George Rimar47936762016-01-16 00:49:19 +0000209 void LoadVersionNeeds(const Elf_Shdr *ec) const;
210 void LoadVersionDefs(const Elf_Shdr *sec) const;
211
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000212 const object::ELFObjectFile<ELFT> *ObjF;
Simon Atanasyan72155c32016-01-16 22:40:09 +0000213 DynRegionInfo DynRelRegion;
George Rimar47936762016-01-16 00:49:19 +0000214 DynRegionInfo DynRelaRegion;
Jake Ehrlich0f440d82018-06-28 21:07:34 +0000215 DynRegionInfo DynRelrRegion;
Rafael Espindola944f6552016-02-16 15:16:00 +0000216 DynRegionInfo DynPLTRelRegion;
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000217 DynRegionInfo DynSymRegion;
Rafael Espindolae17c3f32016-02-17 16:48:00 +0000218 DynRegionInfo DynamicTable;
George Rimar47936762016-01-16 00:49:19 +0000219 StringRef DynamicStringTable;
George Rimar47936762016-01-16 00:49:19 +0000220 StringRef SOName;
221 const Elf_Hash *HashTable = nullptr;
222 const Elf_GnuHash *GnuHashTable = nullptr;
George Rimar47936762016-01-16 00:49:19 +0000223 const Elf_Shdr *DotSymtabSec = nullptr;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000224 const Elf_Shdr *DotCGProfileSec = nullptr;
Peter Collingbourne3e227332018-07-17 22:17:18 +0000225 const Elf_Shdr *DotAddrsigSec = nullptr;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000226 StringRef DynSymtabName;
George Rimar47936762016-01-16 00:49:19 +0000227 ArrayRef<Elf_Word> ShndxTable;
228
229 const Elf_Shdr *dot_gnu_version_sec = nullptr; // .gnu.version
230 const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r
231 const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d
232
233 // Records for each version index the corresponding Verdef or Vernaux entry.
234 // This is filled the first time LoadVersionMap() is called.
235 class VersionMapEntry : public PointerIntPair<const void *, 1> {
236 public:
237 // If the integer is 0, this is an Elf_Verdef*.
238 // If the integer is 1, this is an Elf_Vernaux*.
239 VersionMapEntry() : PointerIntPair<const void *, 1>(nullptr, 0) {}
240 VersionMapEntry(const Elf_Verdef *verdef)
241 : PointerIntPair<const void *, 1>(verdef, 0) {}
242 VersionMapEntry(const Elf_Vernaux *vernaux)
243 : PointerIntPair<const void *, 1>(vernaux, 1) {}
Eugene Zelenko416e0592017-06-09 21:41:54 +0000244
George Rimar47936762016-01-16 00:49:19 +0000245 bool isNull() const { return getPointer() == nullptr; }
246 bool isVerdef() const { return !isNull() && getInt() == 0; }
247 bool isVernaux() const { return !isNull() && getInt() == 1; }
248 const Elf_Verdef *getVerdef() const {
249 return isVerdef() ? (const Elf_Verdef *)getPointer() : nullptr;
250 }
251 const Elf_Vernaux *getVernaux() const {
252 return isVernaux() ? (const Elf_Vernaux *)getPointer() : nullptr;
253 }
254 };
255 mutable SmallVector<VersionMapEntry, 16> VersionMap;
256
257public:
258 Elf_Dyn_Range dynamic_table() const {
Rafael Espindolaaafcf752016-04-05 14:47:22 +0000259 return DynamicTable.getAsArrayRef<Elf_Dyn>();
George Rimar47936762016-01-16 00:49:19 +0000260 }
261
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000262 Elf_Sym_Range dynamic_symbols() const {
Rafael Espindolaaafcf752016-04-05 14:47:22 +0000263 return DynSymRegion.getAsArrayRef<Elf_Sym>();
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000264 }
265
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000266 Elf_Rel_Range dyn_rels() const;
267 Elf_Rela_Range dyn_relas() const;
Jake Ehrlich0f440d82018-06-28 21:07:34 +0000268 Elf_Relr_Range dyn_relrs() const;
George Rimar47936762016-01-16 00:49:19 +0000269 std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000270 bool IsDynamic) const;
Simon Atanasyan62d32592017-12-21 10:26:02 +0000271 void getSectionNameIndex(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
272 StringRef &SectionName,
273 unsigned &SectionIndex) const;
James Hendersone50d9cb2019-01-17 15:34:12 +0000274 std::string getStaticSymbolName(uint32_t Index) const;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000275
276 void printSymbolsHelper(bool IsDynamic) const;
George Rimar47936762016-01-16 00:49:19 +0000277 const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000278 const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; }
Peter Collingbourne3e227332018-07-17 22:17:18 +0000279 const Elf_Shdr *getDotAddrsigSec() const { return DotAddrsigSec; }
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000280 ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000281 StringRef getDynamicStringTable() const { return DynamicStringTable; }
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000282 const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
283 const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
Jake Ehrlich0f440d82018-06-28 21:07:34 +0000284 const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; }
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000285 const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +0000286 const Elf_Hash *getHashTable() const { return HashTable; }
287 const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; }
George Rimar47936762016-01-16 00:49:19 +0000288};
289
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000290template <class ELFT>
291void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
292 StringRef StrTable, SymtabName;
293 size_t Entries = 0;
294 Elf_Sym_Range Syms(nullptr, nullptr);
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000295 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000296 if (IsDynamic) {
297 StrTable = DynamicStringTable;
298 Syms = dynamic_symbols();
299 SymtabName = DynSymtabName;
300 if (DynSymRegion.Addr)
301 Entries = DynSymRegion.Size / DynSymRegion.EntSize;
302 } else {
303 if (!DotSymtabSec)
304 return;
305 StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
Rafael Espindola9ea68342016-11-03 13:43:30 +0000306 Syms = unwrapOrError(Obj->symbols(DotSymtabSec));
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000307 SymtabName = unwrapOrError(Obj->getSectionName(DotSymtabSec));
308 Entries = DotSymtabSec->getEntityCount();
309 }
310 if (Syms.begin() == Syms.end())
311 return;
312 ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries);
313 for (const auto &Sym : Syms)
314 ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic);
315}
316
Simon Atanasyan62d32592017-12-21 10:26:02 +0000317template <class ELFT> class MipsGOTParser;
318
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000319template <typename ELFT> class DumpStyle {
320public:
Rui Ueyama478d6352018-01-12 02:28:31 +0000321 using Elf_Shdr = typename ELFT::Shdr;
322 using Elf_Sym = typename ELFT::Sym;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000323
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000324 DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
Eugene Zelenko416e0592017-06-09 21:41:54 +0000325 virtual ~DumpStyle() = default;
326
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000327 virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000328 virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000329 virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +0000330 virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000331 virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0;
332 virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
333 virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000334 virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
Eugene Zelenko416e0592017-06-09 21:41:54 +0000335 size_t Offset) {}
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000336 virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
337 const Elf_Sym *FirstSym, StringRef StrTable,
338 bool IsDynamic) = 0;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +0000339 virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0;
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +0000340 virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000341 virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0;
Peter Collingbourne3e227332018-07-17 22:17:18 +0000342 virtual void printAddrsig(const ELFFile<ELFT> *Obj) = 0;
Saleem Abdulrasool6a405442016-08-30 18:52:02 +0000343 virtual void printNotes(const ELFFile<ELFT> *Obj) = 0;
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +0000344 virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0;
Simon Atanasyan62d32592017-12-21 10:26:02 +0000345 virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
346 virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000347 const ELFDumper<ELFT> *dumper() const { return Dumper; }
Eugene Zelenko416e0592017-06-09 21:41:54 +0000348
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000349private:
350 const ELFDumper<ELFT> *Dumper;
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000351};
352
353template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
354 formatted_raw_ostream OS;
Eugene Zelenko416e0592017-06-09 21:41:54 +0000355
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000356public:
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000357 TYPEDEF_ELF_TYPES(ELFT)
Eugene Zelenko416e0592017-06-09 21:41:54 +0000358
Zachary Turner88bb1632016-05-03 00:28:04 +0000359 GNUStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000360 : DumpStyle<ELFT>(Dumper), OS(W.getOStream()) {}
Eugene Zelenko416e0592017-06-09 21:41:54 +0000361
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000362 void printFileHeaders(const ELFO *Obj) override;
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000363 void printGroupSections(const ELFFile<ELFT> *Obj) override;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000364 void printRelocations(const ELFO *Obj) override;
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +0000365 void printSectionHeaders(const ELFO *Obj) override;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000366 void printSymbols(const ELFO *Obj) override;
367 void printDynamicSymbols(const ELFO *Obj) override;
368 void printDynamicRelocations(const ELFO *Obj) override;
Eugene Zelenko416e0592017-06-09 21:41:54 +0000369 void printSymtabMessage(const ELFO *Obj, StringRef Name,
370 size_t Offset) override;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +0000371 void printProgramHeaders(const ELFO *Obj) override;
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +0000372 void printHashHistogram(const ELFFile<ELFT> *Obj) override;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000373 void printCGProfile(const ELFFile<ELFT> *Obj) override;
Peter Collingbourne3e227332018-07-17 22:17:18 +0000374 void printAddrsig(const ELFFile<ELFT> *Obj) override;
Saleem Abdulrasool6a405442016-08-30 18:52:02 +0000375 void printNotes(const ELFFile<ELFT> *Obj) override;
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +0000376 void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
Simon Atanasyan62d32592017-12-21 10:26:02 +0000377 void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
378 void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000379
380private:
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000381 struct Field {
382 StringRef Str;
383 unsigned Column;
Eugene Zelenko416e0592017-06-09 21:41:54 +0000384
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000385 Field(StringRef S, unsigned Col) : Str(S), Column(Col) {}
386 Field(unsigned Col) : Str(""), Column(Col) {}
387 };
388
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000389 template <typename T, typename TEnum>
390 std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
391 for (const auto &EnumItem : EnumValues)
392 if (EnumItem.Value == Value)
393 return EnumItem.AltName;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000394 return to_hexString(Value, false);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000395 }
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000396
Simon Atanasyan19932542018-10-25 05:39:27 +0000397 template <typename T, typename TEnum>
398 std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues,
399 TEnum EnumMask1 = {}, TEnum EnumMask2 = {},
400 TEnum EnumMask3 = {}) {
401 std::string Str;
402 for (const auto &Flag : EnumValues) {
403 if (Flag.Value == 0)
404 continue;
405
406 TEnum EnumMask{};
407 if (Flag.Value & EnumMask1)
408 EnumMask = EnumMask1;
409 else if (Flag.Value & EnumMask2)
410 EnumMask = EnumMask2;
411 else if (Flag.Value & EnumMask3)
412 EnumMask = EnumMask3;
413 bool IsEnum = (Flag.Value & EnumMask) != 0;
414 if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
415 (IsEnum && (Value & EnumMask) == Flag.Value)) {
416 if (!Str.empty())
417 Str += ", ";
418 Str += Flag.AltName;
419 }
420 }
421 return Str;
422 }
423
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000424 formatted_raw_ostream &printField(struct Field F) {
425 if (F.Column != 0)
426 OS.PadToColumn(F.Column);
427 OS << F.Str;
428 OS.flush();
429 return OS;
430 }
Hemant Kulkarnia6ee9fd2016-11-23 18:04:23 +0000431 void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym,
432 StringRef StrTable, uint32_t Bucket);
Jake Ehrlich0f440d82018-06-28 21:07:34 +0000433 void printRelocHeader(unsigned SType);
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000434 void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
435 const Elf_Rela &R, bool IsRela);
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000436 void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
437 StringRef StrTable, bool IsDynamic) override;
438 std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
439 const Elf_Sym *FirstSym);
Hemant Kulkarnia79c7982016-03-29 02:41:49 +0000440 void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +0000441 bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
442 bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
443 bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
444 bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000445};
446
447template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
448public:
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000449 TYPEDEF_ELF_TYPES(ELFT)
Eugene Zelenko416e0592017-06-09 21:41:54 +0000450
Zachary Turner88bb1632016-05-03 00:28:04 +0000451 LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000452 : DumpStyle<ELFT>(Dumper), W(W) {}
453
454 void printFileHeaders(const ELFO *Obj) override;
Hemant Kulkarni206ba842016-03-09 19:16:13 +0000455 void printGroupSections(const ELFFile<ELFT> *Obj) override;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000456 void printRelocations(const ELFO *Obj) override;
457 void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +0000458 void printSectionHeaders(const ELFO *Obj) override;
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000459 void printSymbols(const ELFO *Obj) override;
460 void printDynamicSymbols(const ELFO *Obj) override;
461 void printDynamicRelocations(const ELFO *Obj) override;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +0000462 void printProgramHeaders(const ELFO *Obj) override;
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +0000463 void printHashHistogram(const ELFFile<ELFT> *Obj) override;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000464 void printCGProfile(const ELFFile<ELFT> *Obj) override;
Peter Collingbourne3e227332018-07-17 22:17:18 +0000465 void printAddrsig(const ELFFile<ELFT> *Obj) override;
Saleem Abdulrasool6a405442016-08-30 18:52:02 +0000466 void printNotes(const ELFFile<ELFT> *Obj) override;
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +0000467 void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
Simon Atanasyan62d32592017-12-21 10:26:02 +0000468 void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
469 void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000470
471private:
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000472 void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000473 void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +0000474 void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
475 StringRef StrTable, bool IsDynamic) override;
Eugene Zelenko416e0592017-06-09 21:41:54 +0000476
Zachary Turner88bb1632016-05-03 00:28:04 +0000477 ScopedPrinter &W;
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000478};
479
Eugene Zelenko416e0592017-06-09 21:41:54 +0000480} // end anonymous namespace
George Rimar47936762016-01-16 00:49:19 +0000481
482namespace llvm {
483
484template <class ELFT>
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000485static std::error_code createELFDumper(const ELFObjectFile<ELFT> *Obj,
Zachary Turner88bb1632016-05-03 00:28:04 +0000486 ScopedPrinter &Writer,
George Rimar47936762016-01-16 00:49:19 +0000487 std::unique_ptr<ObjDumper> &Result) {
488 Result.reset(new ELFDumper<ELFT>(Obj, Writer));
489 return readobj_error::success;
490}
491
492std::error_code createELFDumper(const object::ObjectFile *Obj,
Zachary Turner88bb1632016-05-03 00:28:04 +0000493 ScopedPrinter &Writer,
George Rimar47936762016-01-16 00:49:19 +0000494 std::unique_ptr<ObjDumper> &Result) {
495 // Little-endian 32-bit
496 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000497 return createELFDumper(ELFObj, Writer, Result);
George Rimar47936762016-01-16 00:49:19 +0000498
499 // Big-endian 32-bit
500 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000501 return createELFDumper(ELFObj, Writer, Result);
George Rimar47936762016-01-16 00:49:19 +0000502
503 // Little-endian 64-bit
504 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000505 return createELFDumper(ELFObj, Writer, Result);
George Rimar47936762016-01-16 00:49:19 +0000506
507 // Big-endian 64-bit
508 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000509 return createELFDumper(ELFObj, Writer, Result);
George Rimar47936762016-01-16 00:49:19 +0000510
511 return readobj_error::unsupported_obj_file_format;
512}
513
Eugene Zelenko416e0592017-06-09 21:41:54 +0000514} // end namespace llvm
George Rimar47936762016-01-16 00:49:19 +0000515
516// Iterate through the versions needed section, and place each Elf_Vernaux
517// in the VersionMap according to its index.
518template <class ELFT>
519void ELFDumper<ELFT>::LoadVersionNeeds(const Elf_Shdr *sec) const {
520 unsigned vn_size = sec->sh_size; // Size of section in bytes
521 unsigned vn_count = sec->sh_info; // Number of Verneed entries
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000522 const char *sec_start = (const char *)ObjF->getELFFile()->base() + sec->sh_offset;
George Rimar47936762016-01-16 00:49:19 +0000523 const char *sec_end = sec_start + vn_size;
524 // The first Verneed entry is at the start of the section.
525 const char *p = sec_start;
526 for (unsigned i = 0; i < vn_count; i++) {
527 if (p + sizeof(Elf_Verneed) > sec_end)
528 report_fatal_error("Section ended unexpectedly while scanning "
529 "version needed records.");
530 const Elf_Verneed *vn = reinterpret_cast<const Elf_Verneed *>(p);
531 if (vn->vn_version != ELF::VER_NEED_CURRENT)
532 report_fatal_error("Unexpected verneed version");
533 // Iterate through the Vernaux entries
534 const char *paux = p + vn->vn_aux;
535 for (unsigned j = 0; j < vn->vn_cnt; j++) {
536 if (paux + sizeof(Elf_Vernaux) > sec_end)
537 report_fatal_error("Section ended unexpected while scanning auxiliary "
538 "version needed records.");
539 const Elf_Vernaux *vna = reinterpret_cast<const Elf_Vernaux *>(paux);
540 size_t index = vna->vna_other & ELF::VERSYM_VERSION;
541 if (index >= VersionMap.size())
542 VersionMap.resize(index + 1);
543 VersionMap[index] = VersionMapEntry(vna);
544 paux += vna->vna_next;
545 }
546 p += vn->vn_next;
547 }
548}
549
550// Iterate through the version definitions, and place each Elf_Verdef
551// in the VersionMap according to its index.
552template <class ELFT>
553void ELFDumper<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const {
554 unsigned vd_size = sec->sh_size; // Size of section in bytes
555 unsigned vd_count = sec->sh_info; // Number of Verdef entries
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000556 const char *sec_start = (const char *)ObjF->getELFFile()->base() + sec->sh_offset;
George Rimar47936762016-01-16 00:49:19 +0000557 const char *sec_end = sec_start + vd_size;
558 // The first Verdef entry is at the start of the section.
559 const char *p = sec_start;
560 for (unsigned i = 0; i < vd_count; i++) {
561 if (p + sizeof(Elf_Verdef) > sec_end)
562 report_fatal_error("Section ended unexpectedly while scanning "
563 "version definitions.");
564 const Elf_Verdef *vd = reinterpret_cast<const Elf_Verdef *>(p);
565 if (vd->vd_version != ELF::VER_DEF_CURRENT)
566 report_fatal_error("Unexpected verdef version");
567 size_t index = vd->vd_ndx & ELF::VERSYM_VERSION;
568 if (index >= VersionMap.size())
569 VersionMap.resize(index + 1);
570 VersionMap[index] = VersionMapEntry(vd);
571 p += vd->vd_next;
572 }
573}
574
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000575template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() const {
George Rimar47936762016-01-16 00:49:19 +0000576 // If there is no dynamic symtab or version table, there is nothing to do.
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000577 if (!DynSymRegion.Addr || !dot_gnu_version_sec)
George Rimar47936762016-01-16 00:49:19 +0000578 return;
579
580 // Has the VersionMap already been loaded?
Jordan Rupprecht16a0de22018-12-20 00:57:06 +0000581 if (!VersionMap.empty())
George Rimar47936762016-01-16 00:49:19 +0000582 return;
583
584 // The first two version indexes are reserved.
585 // Index 0 is LOCAL, index 1 is GLOBAL.
586 VersionMap.push_back(VersionMapEntry());
587 VersionMap.push_back(VersionMapEntry());
588
589 if (dot_gnu_version_d_sec)
590 LoadVersionDefs(dot_gnu_version_d_sec);
591
592 if (dot_gnu_version_r_sec)
593 LoadVersionNeeds(dot_gnu_version_r_sec);
594}
595
George Rimar47936762016-01-16 00:49:19 +0000596template <typename ELFO, class ELFT>
Zachary Turner88bb1632016-05-03 00:28:04 +0000597static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
George Rimar47936762016-01-16 00:49:19 +0000598 const typename ELFO::Elf_Shdr *Sec,
Zachary Turner88bb1632016-05-03 00:28:04 +0000599 ScopedPrinter &W) {
George Rimar47936762016-01-16 00:49:19 +0000600 DictScope SS(W, "Version symbols");
601 if (!Sec)
602 return;
Rafael Espindolaf04f1842016-02-17 16:21:49 +0000603 StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
George Rimar47936762016-01-16 00:49:19 +0000604 W.printNumber("Section Name", Name, Sec->sh_name);
605 W.printHex("Address", Sec->sh_addr);
606 W.printHex("Offset", Sec->sh_offset);
607 W.printNumber("Link", Sec->sh_link);
608
George Rimar47936762016-01-16 00:49:19 +0000609 const uint8_t *P = (const uint8_t *)Obj->base() + Sec->sh_offset;
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000610 StringRef StrTable = Dumper->getDynamicStringTable();
George Rimar47936762016-01-16 00:49:19 +0000611
612 // Same number of entries in the dynamic symbol table (DT_SYMTAB).
613 ListScope Syms(W, "Symbols");
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000614 for (const typename ELFO::Elf_Sym &Sym : Dumper->dynamic_symbols()) {
George Rimar47936762016-01-16 00:49:19 +0000615 DictScope S(W, "Symbol");
616 std::string FullSymbolName =
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000617 Dumper->getFullSymbolName(&Sym, StrTable, true /* IsDynamic */);
George Rimar47936762016-01-16 00:49:19 +0000618 W.printNumber("Version", *P);
619 W.printString("Name", FullSymbolName);
620 P += sizeof(typename ELFO::Elf_Half);
621 }
622}
623
George Rimarcd36e182016-06-07 11:04:49 +0000624static const EnumEntry<unsigned> SymVersionFlags[] = {
625 {"Base", "BASE", VER_FLG_BASE},
626 {"Weak", "WEAK", VER_FLG_WEAK},
627 {"Info", "INFO", VER_FLG_INFO}};
628
George Rimar47936762016-01-16 00:49:19 +0000629template <typename ELFO, class ELFT>
630static void printVersionDefinitionSection(ELFDumper<ELFT> *Dumper,
631 const ELFO *Obj,
632 const typename ELFO::Elf_Shdr *Sec,
Zachary Turner88bb1632016-05-03 00:28:04 +0000633 ScopedPrinter &W) {
Eugene Zelenko416e0592017-06-09 21:41:54 +0000634 using VerDef = typename ELFO::Elf_Verdef;
635 using VerdAux = typename ELFO::Elf_Verdaux;
George Rimarff8b5392016-06-22 13:43:38 +0000636
637 DictScope SD(W, "SHT_GNU_verdef");
George Rimar47936762016-01-16 00:49:19 +0000638 if (!Sec)
639 return;
George Rimar47936762016-01-16 00:49:19 +0000640
George Rimar47936762016-01-16 00:49:19 +0000641 // The number of entries in the section SHT_GNU_verdef
642 // is determined by DT_VERDEFNUM tag.
George Rimarff8b5392016-06-22 13:43:38 +0000643 unsigned VerDefsNum = 0;
George Rimar47936762016-01-16 00:49:19 +0000644 for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) {
Xing GUOc9436082018-12-01 12:27:24 +0000645 if (Dyn.d_tag == DT_VERDEFNUM) {
George Rimarff8b5392016-06-22 13:43:38 +0000646 VerDefsNum = Dyn.d_un.d_val;
Xing GUOc9436082018-12-01 12:27:24 +0000647 break;
648 }
George Rimar47936762016-01-16 00:49:19 +0000649 }
Xing GUOc9436082018-12-01 12:27:24 +0000650
George Rimar47936762016-01-16 00:49:19 +0000651 const uint8_t *SecStartAddress =
652 (const uint8_t *)Obj->base() + Sec->sh_offset;
653 const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size;
654 const uint8_t *P = SecStartAddress;
Rafael Espindolaf04f1842016-02-17 16:21:49 +0000655 const typename ELFO::Elf_Shdr *StrTab =
656 unwrapOrError(Obj->getSection(Sec->sh_link));
George Rimar47936762016-01-16 00:49:19 +0000657
George Rimarff8b5392016-06-22 13:43:38 +0000658 while (VerDefsNum--) {
659 if (P + sizeof(VerDef) > SecEndAddress)
George Rimar47936762016-01-16 00:49:19 +0000660 report_fatal_error("invalid offset in the section");
George Rimarff8b5392016-06-22 13:43:38 +0000661
662 auto *VD = reinterpret_cast<const VerDef *>(P);
663 DictScope Def(W, "Definition");
664 W.printNumber("Version", VD->vd_version);
665 W.printEnum("Flags", VD->vd_flags, makeArrayRef(SymVersionFlags));
George Rimar47936762016-01-16 00:49:19 +0000666 W.printNumber("Index", VD->vd_ndx);
Davide Italiano22b3ad862016-05-02 02:30:18 +0000667 W.printNumber("Hash", VD->vd_hash);
Rafael Espindolaf04f1842016-02-17 16:21:49 +0000668 W.printString("Name",
669 StringRef((const char *)(Obj->base() + StrTab->sh_offset +
670 VD->getAux()->vda_name)));
George Rimarff8b5392016-06-22 13:43:38 +0000671 if (!VD->vd_cnt)
672 report_fatal_error("at least one definition string must exist");
673 if (VD->vd_cnt > 2)
674 report_fatal_error("more than one predecessor is not expected");
675
676 if (VD->vd_cnt == 2) {
677 const uint8_t *PAux = P + VD->vd_aux + VD->getAux()->vda_next;
678 const VerdAux *Aux = reinterpret_cast<const VerdAux *>(PAux);
679 W.printString("Predecessor",
680 StringRef((const char *)(Obj->base() + StrTab->sh_offset +
681 Aux->vda_name)));
682 }
683
George Rimar47936762016-01-16 00:49:19 +0000684 P += VD->vd_next;
685 }
686}
687
George Rimarcd36e182016-06-07 11:04:49 +0000688template <typename ELFO, class ELFT>
689static void printVersionDependencySection(ELFDumper<ELFT> *Dumper,
690 const ELFO *Obj,
691 const typename ELFO::Elf_Shdr *Sec,
692 ScopedPrinter &W) {
Eugene Zelenko416e0592017-06-09 21:41:54 +0000693 using VerNeed = typename ELFO::Elf_Verneed;
694 using VernAux = typename ELFO::Elf_Vernaux;
George Rimarcd36e182016-06-07 11:04:49 +0000695
696 DictScope SD(W, "SHT_GNU_verneed");
697 if (!Sec)
698 return;
699
700 unsigned VerNeedNum = 0;
Xing GUOc9436082018-12-01 12:27:24 +0000701 for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) {
702 if (Dyn.d_tag == DT_VERNEEDNUM) {
George Rimarcd36e182016-06-07 11:04:49 +0000703 VerNeedNum = Dyn.d_un.d_val;
Xing GUOc9436082018-12-01 12:27:24 +0000704 break;
705 }
706 }
George Rimarcd36e182016-06-07 11:04:49 +0000707
708 const uint8_t *SecData = (const uint8_t *)Obj->base() + Sec->sh_offset;
709 const typename ELFO::Elf_Shdr *StrTab =
710 unwrapOrError(Obj->getSection(Sec->sh_link));
711
712 const uint8_t *P = SecData;
713 for (unsigned I = 0; I < VerNeedNum; ++I) {
714 const VerNeed *Need = reinterpret_cast<const VerNeed *>(P);
715 DictScope Entry(W, "Dependency");
716 W.printNumber("Version", Need->vn_version);
717 W.printNumber("Count", Need->vn_cnt);
718 W.printString("FileName",
719 StringRef((const char *)(Obj->base() + StrTab->sh_offset +
720 Need->vn_file)));
721
722 const uint8_t *PAux = P + Need->vn_aux;
723 for (unsigned J = 0; J < Need->vn_cnt; ++J) {
724 const VernAux *Aux = reinterpret_cast<const VernAux *>(PAux);
725 DictScope Entry(W, "Entry");
726 W.printNumber("Hash", Aux->vna_hash);
727 W.printEnum("Flags", Aux->vna_flags, makeArrayRef(SymVersionFlags));
728 W.printNumber("Index", Aux->vna_other);
729 W.printString("Name",
730 StringRef((const char *)(Obj->base() + StrTab->sh_offset +
731 Aux->vna_name)));
732 PAux += Aux->vna_next;
733 }
734 P += Need->vn_next;
735 }
736}
737
George Rimar47936762016-01-16 00:49:19 +0000738template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
739 // Dump version symbol section.
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000740 printVersionSymbolSection(this, ObjF->getELFFile(), dot_gnu_version_sec, W);
George Rimar47936762016-01-16 00:49:19 +0000741
742 // Dump version definition section.
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000743 printVersionDefinitionSection(this, ObjF->getELFFile(), dot_gnu_version_d_sec, W);
George Rimarcd36e182016-06-07 11:04:49 +0000744
745 // Dump version dependency section.
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000746 printVersionDependencySection(this, ObjF->getELFFile(), dot_gnu_version_r_sec, W);
George Rimar47936762016-01-16 00:49:19 +0000747}
748
749template <typename ELFT>
750StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab,
751 const Elf_Sym *symb,
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000752 bool &IsDefault) const {
George Rimar47936762016-01-16 00:49:19 +0000753 // This is a dynamic symbol. Look in the GNU symbol version table.
754 if (!dot_gnu_version_sec) {
755 // No version table.
756 IsDefault = false;
757 return StringRef("");
758 }
759
760 // Determine the position in the symbol table of this entry.
761 size_t entry_index = (reinterpret_cast<uintptr_t>(symb) -
Rafael Espindolace2fbdd2016-02-17 15:38:21 +0000762 reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) /
George Rimar47936762016-01-16 00:49:19 +0000763 sizeof(Elf_Sym);
764
765 // Get the corresponding version index entry
Rafael Espindolaed1395a2016-11-03 18:05:33 +0000766 const Elf_Versym *vs = unwrapOrError(
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000767 ObjF->getELFFile()->template getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index));
George Rimar47936762016-01-16 00:49:19 +0000768 size_t version_index = vs->vs_index & ELF::VERSYM_VERSION;
769
770 // Special markers for unversioned symbols.
771 if (version_index == ELF::VER_NDX_LOCAL ||
772 version_index == ELF::VER_NDX_GLOBAL) {
773 IsDefault = false;
774 return StringRef("");
775 }
776
777 // Lookup this symbol in the version table
778 LoadVersionMap();
779 if (version_index >= VersionMap.size() || VersionMap[version_index].isNull())
780 reportError("Invalid version entry");
781 const VersionMapEntry &entry = VersionMap[version_index];
782
783 // Get the version name string
784 size_t name_offset;
785 if (entry.isVerdef()) {
786 // The first Verdaux entry holds the name.
787 name_offset = entry.getVerdef()->getAux()->vda_name;
788 IsDefault = !(vs->vs_index & ELF::VERSYM_HIDDEN);
789 } else {
790 name_offset = entry.getVernaux()->vna_name;
791 IsDefault = false;
792 }
793 if (name_offset >= StrTab.size())
794 reportError("Invalid string offset");
795 return StringRef(StrTab.data() + name_offset);
796}
797
James Hendersone50d9cb2019-01-17 15:34:12 +0000798static std::string maybeDemangle(StringRef Name) {
799 return opts::Demangle ? demangle(Name) : Name.str();
800}
801
George Rimar47936762016-01-16 00:49:19 +0000802template <typename ELFT>
James Hendersone50d9cb2019-01-17 15:34:12 +0000803std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000804 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000805 StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
806 Elf_Sym_Range Syms = unwrapOrError(Obj->symbols(DotSymtabSec));
807 if (Index >= Syms.size())
808 reportError("Invalid symbol index");
809 const Elf_Sym *Sym = &Syms[Index];
James Hendersone50d9cb2019-01-17 15:34:12 +0000810 return maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
Michael J. Spencerae6eeae2018-06-02 16:33:01 +0000811}
812
813template <typename ELFT>
George Rimar47936762016-01-16 00:49:19 +0000814std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
815 StringRef StrTable,
Hemant Kulkarnic030f232016-03-15 17:25:31 +0000816 bool IsDynamic) const {
James Hendersone50d9cb2019-01-17 15:34:12 +0000817 std::string SymbolName =
818 maybeDemangle(unwrapOrError(Symbol->getName(StrTable)));
George Rimar47936762016-01-16 00:49:19 +0000819 if (!IsDynamic)
820 return SymbolName;
821
George Rimar47936762016-01-16 00:49:19 +0000822 bool IsDefault;
823 StringRef Version = getSymbolVersion(StrTable, &*Symbol, IsDefault);
James Henderson6135b0f82019-01-08 10:58:05 +0000824 if (!Version.empty()) {
James Hendersone50d9cb2019-01-17 15:34:12 +0000825 SymbolName += (IsDefault ? "@@" : "@");
826 SymbolName += Version;
James Henderson6135b0f82019-01-08 10:58:05 +0000827 }
James Hendersone50d9cb2019-01-17 15:34:12 +0000828 return SymbolName;
George Rimar47936762016-01-16 00:49:19 +0000829}
830
Rafael Espindola714c2952016-11-03 14:41:17 +0000831template <typename ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +0000832void ELFDumper<ELFT>::getSectionNameIndex(const Elf_Sym *Symbol,
833 const Elf_Sym *FirstSym,
834 StringRef &SectionName,
835 unsigned &SectionIndex) const {
George Rimar47936762016-01-16 00:49:19 +0000836 SectionIndex = Symbol->st_shndx;
837 if (Symbol->isUndefined())
838 SectionName = "Undefined";
839 else if (Symbol->isProcessorSpecific())
840 SectionName = "Processor Specific";
841 else if (Symbol->isOSSpecific())
842 SectionName = "Operating System Specific";
843 else if (Symbol->isAbsolute())
844 SectionName = "Absolute";
845 else if (Symbol->isCommon())
846 SectionName = "Common";
847 else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
848 SectionName = "Reserved";
849 else {
850 if (SectionIndex == SHN_XINDEX)
Rafael Espindola714c2952016-11-03 14:41:17 +0000851 SectionIndex = unwrapOrError(object::getExtendedSymbolTableIndex<ELFT>(
852 Symbol, FirstSym, ShndxTable));
Luke Cheesemanf57d7d82018-12-18 10:37:42 +0000853 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Rafael Espindola714c2952016-11-03 14:41:17 +0000854 const typename ELFT::Shdr *Sec =
Simon Atanasyan62d32592017-12-21 10:26:02 +0000855 unwrapOrError(Obj->getSection(SectionIndex));
856 SectionName = unwrapOrError(Obj->getSectionName(Sec));
George Rimar47936762016-01-16 00:49:19 +0000857 }
858}
859
860template <class ELFO>
Simon Atanasyancb1175c2016-02-09 18:45:35 +0000861static const typename ELFO::Elf_Shdr *
862findNotEmptySectionByAddress(const ELFO *Obj, uint64_t Addr) {
Rafael Espindola25be8c82016-11-02 14:10:57 +0000863 for (const auto &Shdr : unwrapOrError(Obj->sections()))
Simon Atanasyancb1175c2016-02-09 18:45:35 +0000864 if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
George Rimar47936762016-01-16 00:49:19 +0000865 return &Shdr;
866 return nullptr;
867}
868
869template <class ELFO>
870static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj,
871 StringRef Name) {
Rafael Espindola25be8c82016-11-02 14:10:57 +0000872 for (const auto &Shdr : unwrapOrError(Obj.sections())) {
Rafael Espindolaf04f1842016-02-17 16:21:49 +0000873 if (Name == unwrapOrError(Obj.getSectionName(&Shdr)))
George Rimar47936762016-01-16 00:49:19 +0000874 return &Shdr;
875 }
876 return nullptr;
877}
878
879static const EnumEntry<unsigned> ElfClass[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000880 {"None", "none", ELF::ELFCLASSNONE},
881 {"32-bit", "ELF32", ELF::ELFCLASS32},
882 {"64-bit", "ELF64", ELF::ELFCLASS64},
George Rimar47936762016-01-16 00:49:19 +0000883};
884
885static const EnumEntry<unsigned> ElfDataEncoding[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000886 {"None", "none", ELF::ELFDATANONE},
887 {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB},
888 {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB},
George Rimar47936762016-01-16 00:49:19 +0000889};
890
891static const EnumEntry<unsigned> ElfObjectFileType[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000892 {"None", "NONE (none)", ELF::ET_NONE},
893 {"Relocatable", "REL (Relocatable file)", ELF::ET_REL},
894 {"Executable", "EXEC (Executable file)", ELF::ET_EXEC},
895 {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN},
896 {"Core", "CORE (Core file)", ELF::ET_CORE},
George Rimar47936762016-01-16 00:49:19 +0000897};
898
899static const EnumEntry<unsigned> ElfOSABI[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000900 {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE},
901 {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX},
902 {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD},
903 {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX},
904 {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD},
905 {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS},
906 {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX},
907 {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX},
908 {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD},
909 {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64},
910 {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO},
911 {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD},
912 {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS},
913 {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK},
914 {"AROS", "AROS", ELF::ELFOSABI_AROS},
915 {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS},
916 {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI},
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000917 {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE}
George Rimar47936762016-01-16 00:49:19 +0000918};
919
Konstantin Zhuravlyov121125f2017-10-02 20:49:58 +0000920static const EnumEntry<unsigned> AMDGPUElfOSABI[] = {
Konstantin Zhuravlyov0aa94d32017-10-03 21:14:14 +0000921 {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA},
922 {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL},
923 {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D}
Konstantin Zhuravlyov121125f2017-10-02 20:49:58 +0000924};
925
926static const EnumEntry<unsigned> ARMElfOSABI[] = {
927 {"ARM", "ARM", ELF::ELFOSABI_ARM}
928};
929
930static const EnumEntry<unsigned> C6000ElfOSABI[] = {
931 {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI},
932 {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX}
933};
934
George Rimar47936762016-01-16 00:49:19 +0000935static const EnumEntry<unsigned> ElfMachineType[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +0000936 ENUM_ENT(EM_NONE, "None"),
937 ENUM_ENT(EM_M32, "WE32100"),
938 ENUM_ENT(EM_SPARC, "Sparc"),
939 ENUM_ENT(EM_386, "Intel 80386"),
940 ENUM_ENT(EM_68K, "MC68000"),
941 ENUM_ENT(EM_88K, "MC88000"),
942 ENUM_ENT(EM_IAMCU, "EM_IAMCU"),
943 ENUM_ENT(EM_860, "Intel 80860"),
944 ENUM_ENT(EM_MIPS, "MIPS R3000"),
945 ENUM_ENT(EM_S370, "IBM System/370"),
946 ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"),
947 ENUM_ENT(EM_PARISC, "HPPA"),
948 ENUM_ENT(EM_VPP500, "Fujitsu VPP500"),
949 ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"),
950 ENUM_ENT(EM_960, "Intel 80960"),
951 ENUM_ENT(EM_PPC, "PowerPC"),
952 ENUM_ENT(EM_PPC64, "PowerPC64"),
953 ENUM_ENT(EM_S390, "IBM S/390"),
954 ENUM_ENT(EM_SPU, "SPU"),
955 ENUM_ENT(EM_V800, "NEC V800 series"),
956 ENUM_ENT(EM_FR20, "Fujistsu FR20"),
957 ENUM_ENT(EM_RH32, "TRW RH-32"),
958 ENUM_ENT(EM_RCE, "Motorola RCE"),
959 ENUM_ENT(EM_ARM, "ARM"),
960 ENUM_ENT(EM_ALPHA, "EM_ALPHA"),
961 ENUM_ENT(EM_SH, "Hitachi SH"),
962 ENUM_ENT(EM_SPARCV9, "Sparc v9"),
963 ENUM_ENT(EM_TRICORE, "Siemens Tricore"),
964 ENUM_ENT(EM_ARC, "ARC"),
965 ENUM_ENT(EM_H8_300, "Hitachi H8/300"),
966 ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"),
967 ENUM_ENT(EM_H8S, "Hitachi H8S"),
968 ENUM_ENT(EM_H8_500, "Hitachi H8/500"),
969 ENUM_ENT(EM_IA_64, "Intel IA-64"),
970 ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"),
971 ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"),
972 ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"),
973 ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"),
974 ENUM_ENT(EM_PCP, "Siemens PCP"),
975 ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"),
976 ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"),
977 ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"),
978 ENUM_ENT(EM_ME16, "Toyota ME16 processor"),
979 ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"),
980 ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"),
981 ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"),
982 ENUM_ENT(EM_PDSP, "Sony DSP processor"),
983 ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"),
984 ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"),
985 ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"),
986 ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"),
987 ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"),
988 ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"),
989 ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"),
990 ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"),
991 ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"),
992 ENUM_ENT(EM_SVX, "Silicon Graphics SVx"),
993 ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"),
994 ENUM_ENT(EM_VAX, "Digital VAX"),
995 ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"),
996 ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"),
997 ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"),
998 ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"),
999 ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"),
1000 ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"),
1001 ENUM_ENT(EM_PRISM, "Vitesse Prism"),
1002 ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"),
1003 ENUM_ENT(EM_FR30, "Fujitsu FR30"),
1004 ENUM_ENT(EM_D10V, "Mitsubishi D10V"),
1005 ENUM_ENT(EM_D30V, "Mitsubishi D30V"),
1006 ENUM_ENT(EM_V850, "NEC v850"),
1007 ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"),
1008 ENUM_ENT(EM_MN10300, "Matsushita MN10300"),
1009 ENUM_ENT(EM_MN10200, "Matsushita MN10200"),
1010 ENUM_ENT(EM_PJ, "picoJava"),
1011 ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"),
1012 ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"),
1013 ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"),
1014 ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"),
1015 ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"),
1016 ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"),
1017 ENUM_ENT(EM_TPC, "Tenor Network TPC processor"),
1018 ENUM_ENT(EM_SNP1K, "EM_SNP1K"),
1019 ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"),
1020 ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"),
1021 ENUM_ENT(EM_MAX, "MAX Processor"),
1022 ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"),
1023 ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"),
1024 ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"),
1025 ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"),
1026 ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"),
1027 ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"),
1028 ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"),
1029 ENUM_ENT(EM_UNICORE, "Unicore"),
1030 ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"),
1031 ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"),
1032 ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"),
1033 ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"),
1034 ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"),
1035 ENUM_ENT(EM_C166, "Infineon Technologies xc16x"),
1036 ENUM_ENT(EM_M16C, "Renesas M16C"),
1037 ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"),
1038 ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"),
1039 ENUM_ENT(EM_M32C, "Renesas M32C"),
1040 ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"),
1041 ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"),
1042 ENUM_ENT(EM_SHARC, "EM_SHARC"),
1043 ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"),
1044 ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"),
1045 ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"),
1046 ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"),
1047 ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"),
1048 ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"),
1049 ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"),
1050 ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"),
1051 ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"),
1052 ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"),
1053 ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"),
1054 ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"),
1055 ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"),
1056 ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"),
1057 ENUM_ENT(EM_8051, "Intel 8051 and variants"),
1058 ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"),
1059 ENUM_ENT(EM_NDS32, "Andes Technology compact code size embedded RISC processor family"),
1060 ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"),
1061 ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"),
1062 ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"),
1063 ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"),
1064 ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"),
1065 ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"),
1066 ENUM_ENT(EM_RX, "Renesas RX"),
1067 ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"),
1068 ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"),
1069 ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"),
1070 ENUM_ENT(EM_CR16, "Xilinx MicroBlaze"),
1071 ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"),
1072 ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"),
1073 ENUM_ENT(EM_L10M, "EM_L10M"),
1074 ENUM_ENT(EM_K10M, "EM_K10M"),
1075 ENUM_ENT(EM_AARCH64, "AArch64"),
Dylan McKaydffaaa32017-09-27 22:39:37 +00001076 ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"),
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00001077 ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"),
1078 ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"),
1079 ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"),
1080 ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"),
1081 ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"),
1082 ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"),
1083 ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"),
1084 ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"),
1085 ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"),
1086 ENUM_ENT(EM_OPEN8, "EM_OPEN8"),
1087 ENUM_ENT(EM_RL78, "Renesas RL78"),
1088 ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"),
1089 ENUM_ENT(EM_78KOR, "EM_78KOR"),
1090 ENUM_ENT(EM_56800EX, "EM_56800EX"),
1091 ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"),
Alex Bradbury1524f622016-11-01 16:59:37 +00001092 ENUM_ENT(EM_RISCV, "RISC-V"),
Jacques Pienaarea9f25a2016-03-01 21:21:42 +00001093 ENUM_ENT(EM_LANAI, "EM_LANAI"),
Alexei Starovoitovcfb51f52016-07-15 22:27:55 +00001094 ENUM_ENT(EM_BPF, "EM_BPF"),
George Rimar47936762016-01-16 00:49:19 +00001095};
1096
1097static const EnumEntry<unsigned> ElfSymbolBindings[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00001098 {"Local", "LOCAL", ELF::STB_LOCAL},
1099 {"Global", "GLOBAL", ELF::STB_GLOBAL},
1100 {"Weak", "WEAK", ELF::STB_WEAK},
1101 {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
George Rimar47936762016-01-16 00:49:19 +00001102
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00001103static const EnumEntry<unsigned> ElfSymbolVisibilities[] = {
1104 {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT},
1105 {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL},
1106 {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN},
1107 {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}};
1108
George Rimar47936762016-01-16 00:49:19 +00001109static const EnumEntry<unsigned> ElfSymbolTypes[] = {
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00001110 {"None", "NOTYPE", ELF::STT_NOTYPE},
1111 {"Object", "OBJECT", ELF::STT_OBJECT},
1112 {"Function", "FUNC", ELF::STT_FUNC},
1113 {"Section", "SECTION", ELF::STT_SECTION},
1114 {"File", "FILE", ELF::STT_FILE},
1115 {"Common", "COMMON", ELF::STT_COMMON},
1116 {"TLS", "TLS", ELF::STT_TLS},
1117 {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC}};
George Rimar47936762016-01-16 00:49:19 +00001118
1119static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
Konstantin Zhuravlyov5b0bf2ff2017-06-05 21:33:40 +00001120 { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL }
George Rimar47936762016-01-16 00:49:19 +00001121};
1122
Hemant Kulkarniab4a46f2016-01-26 19:46:39 +00001123static const char *getGroupType(uint32_t Flag) {
1124 if (Flag & ELF::GRP_COMDAT)
1125 return "COMDAT";
1126 else
1127 return "(unknown)";
1128}
1129
George Rimar47936762016-01-16 00:49:19 +00001130static const EnumEntry<unsigned> ElfSectionFlags[] = {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00001131 ENUM_ENT(SHF_WRITE, "W"),
1132 ENUM_ENT(SHF_ALLOC, "A"),
1133 ENUM_ENT(SHF_EXCLUDE, "E"),
1134 ENUM_ENT(SHF_EXECINSTR, "X"),
1135 ENUM_ENT(SHF_MERGE, "M"),
1136 ENUM_ENT(SHF_STRINGS, "S"),
1137 ENUM_ENT(SHF_INFO_LINK, "I"),
1138 ENUM_ENT(SHF_LINK_ORDER, "L"),
1139 ENUM_ENT(SHF_OS_NONCONFORMING, "o"),
1140 ENUM_ENT(SHF_GROUP, "G"),
1141 ENUM_ENT(SHF_TLS, "T"),
Hemant Kulkarni04ac3d72016-05-12 19:58:52 +00001142 ENUM_ENT(SHF_MASKOS, "o"),
1143 ENUM_ENT(SHF_MASKPROC, "p"),
George Rimarc13c59a2016-05-21 10:16:58 +00001144 ENUM_ENT_1(SHF_COMPRESSED),
1145};
1146
1147static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
1148 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
1149 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION)
Simon Atanasyan2d0d8532016-01-20 19:15:18 +00001150};
1151
Prakhar Bahuguna52a7dd72016-12-15 07:59:08 +00001152static const EnumEntry<unsigned> ElfARMSectionFlags[] = {
1153 LLVM_READOBJ_ENUM_ENT(ELF, SHF_ARM_PURECODE)
1154};
1155
Simon Atanasyan2d0d8532016-01-20 19:15:18 +00001156static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
1157 LLVM_READOBJ_ENUM_ENT(ELF, SHF_HEX_GPREL)
1158};
1159
1160static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
1161 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NODUPES),
1162 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NAMES ),
1163 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_LOCAL ),
1164 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP),
1165 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_GPREL ),
1166 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_MERGE ),
1167 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_ADDR ),
1168 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING )
1169};
1170
1171static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
1172 LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE)
1173};
1174
Hemant Kulkarnic030f232016-03-15 17:25:31 +00001175static std::string getGNUFlags(uint64_t Flags) {
1176 std::string Str;
1177 for (auto Entry : ElfSectionFlags) {
1178 uint64_t Flag = Entry.Value & Flags;
1179 Flags &= ~Entry.Value;
1180 switch (Flag) {
1181 case ELF::SHF_WRITE:
1182 case ELF::SHF_ALLOC:
1183 case ELF::SHF_EXECINSTR:
1184 case ELF::SHF_MERGE:
1185 case ELF::SHF_STRINGS:
1186 case ELF::SHF_INFO_LINK:
1187 case ELF::SHF_LINK_ORDER:
1188 case ELF::SHF_OS_NONCONFORMING:
1189 case ELF::SHF_GROUP:
1190 case ELF::SHF_TLS:
1191 case ELF::SHF_EXCLUDE:
1192 Str += Entry.AltName;
1193 break;
1194 default:
Hemant Kulkarni04ac3d72016-05-12 19:58:52 +00001195 if (Flag & ELF::SHF_MASKOS)
Hemant Kulkarnic030f232016-03-15 17:25:31 +00001196 Str += "o";
Hemant Kulkarni04ac3d72016-05-12 19:58:52 +00001197 else if (Flag & ELF::SHF_MASKPROC)
Hemant Kulkarnic030f232016-03-15 17:25:31 +00001198 Str += "p";
1199 else if (Flag)
1200 Str += "x";
1201 }
1202 }
1203 return Str;
1204}
1205
George Rimar47936762016-01-16 00:49:19 +00001206static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
1207 // Check potentially overlapped processor-specific
1208 // program header type.
1209 switch (Arch) {
George Rimar47936762016-01-16 00:49:19 +00001210 case ELF::EM_ARM:
1211 switch (Type) {
1212 LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
1213 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001214 break;
George Rimar47936762016-01-16 00:49:19 +00001215 case ELF::EM_MIPS:
1216 case ELF::EM_MIPS_RS3_LE:
1217 switch (Type) {
1218 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
1219 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
1220 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
1221 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
1222 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001223 break;
George Rimar47936762016-01-16 00:49:19 +00001224 }
1225
1226 switch (Type) {
1227 LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL );
1228 LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD );
1229 LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
1230 LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
1231 LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE );
1232 LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB );
1233 LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR );
1234 LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS );
1235
1236 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
1237 LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
1238
1239 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
1240 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
George Rimarbcfcb9e2016-10-18 10:54:56 +00001241
1242 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE);
1243 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED);
George Rimar114d3352016-12-06 17:55:52 +00001244 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA);
George Rimarbcfcb9e2016-10-18 10:54:56 +00001245
George Rimar47936762016-01-16 00:49:19 +00001246 default: return "";
1247 }
1248}
1249
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001250static std::string getElfPtType(unsigned Arch, unsigned Type) {
1251 switch (Type) {
Hemant Kulkarni7d564ba2016-03-28 17:20:23 +00001252 LLVM_READOBJ_PHDR_ENUM(ELF, PT_NULL)
1253 LLVM_READOBJ_PHDR_ENUM(ELF, PT_LOAD)
1254 LLVM_READOBJ_PHDR_ENUM(ELF, PT_DYNAMIC)
1255 LLVM_READOBJ_PHDR_ENUM(ELF, PT_INTERP)
1256 LLVM_READOBJ_PHDR_ENUM(ELF, PT_NOTE)
1257 LLVM_READOBJ_PHDR_ENUM(ELF, PT_SHLIB)
1258 LLVM_READOBJ_PHDR_ENUM(ELF, PT_PHDR)
1259 LLVM_READOBJ_PHDR_ENUM(ELF, PT_TLS)
1260 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_EH_FRAME)
1261 LLVM_READOBJ_PHDR_ENUM(ELF, PT_SUNW_UNWIND)
1262 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK)
1263 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO)
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001264 default:
1265 // All machine specific PT_* types
1266 switch (Arch) {
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001267 case ELF::EM_ARM:
1268 if (Type == ELF::PT_ARM_EXIDX)
1269 return "EXIDX";
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001270 break;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001271 case ELF::EM_MIPS:
1272 case ELF::EM_MIPS_RS3_LE:
1273 switch (Type) {
1274 case PT_MIPS_REGINFO:
1275 return "REGINFO";
1276 case PT_MIPS_RTPROC:
1277 return "RTPROC";
1278 case PT_MIPS_OPTIONS:
1279 return "OPTIONS";
1280 case PT_MIPS_ABIFLAGS:
1281 return "ABIFLAGS";
1282 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001283 break;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001284 }
1285 }
1286 return std::string("<unknown>: ") + to_string(format_hex(Type, 1));
1287}
1288
George Rimar47936762016-01-16 00:49:19 +00001289static const EnumEntry<unsigned> ElfSegmentFlags[] = {
1290 LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
1291 LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
1292 LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
1293};
1294
1295static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
Simon Atanasyan19932542018-10-25 05:39:27 +00001296 ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"),
1297 ENUM_ENT(EF_MIPS_PIC, "pic"),
1298 ENUM_ENT(EF_MIPS_CPIC, "cpic"),
1299 ENUM_ENT(EF_MIPS_ABI2, "abi2"),
1300 ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"),
1301 ENUM_ENT(EF_MIPS_FP64, "fp64"),
1302 ENUM_ENT(EF_MIPS_NAN2008, "nan2008"),
1303 ENUM_ENT(EF_MIPS_ABI_O32, "o32"),
1304 ENUM_ENT(EF_MIPS_ABI_O64, "o64"),
1305 ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"),
1306 ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"),
1307 ENUM_ENT(EF_MIPS_MACH_3900, "3900"),
1308 ENUM_ENT(EF_MIPS_MACH_4010, "4010"),
1309 ENUM_ENT(EF_MIPS_MACH_4100, "4100"),
1310 ENUM_ENT(EF_MIPS_MACH_4650, "4650"),
1311 ENUM_ENT(EF_MIPS_MACH_4120, "4120"),
1312 ENUM_ENT(EF_MIPS_MACH_4111, "4111"),
1313 ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"),
1314 ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"),
1315 ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"),
1316 ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"),
1317 ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"),
1318 ENUM_ENT(EF_MIPS_MACH_5400, "5400"),
1319 ENUM_ENT(EF_MIPS_MACH_5900, "5900"),
1320 ENUM_ENT(EF_MIPS_MACH_5500, "5500"),
1321 ENUM_ENT(EF_MIPS_MACH_9000, "9000"),
1322 ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"),
1323 ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"),
1324 ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"),
1325 ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"),
1326 ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"),
1327 ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"),
1328 ENUM_ENT(EF_MIPS_ARCH_1, "mips1"),
1329 ENUM_ENT(EF_MIPS_ARCH_2, "mips2"),
1330 ENUM_ENT(EF_MIPS_ARCH_3, "mips3"),
1331 ENUM_ENT(EF_MIPS_ARCH_4, "mips4"),
1332 ENUM_ENT(EF_MIPS_ARCH_5, "mips5"),
1333 ENUM_ENT(EF_MIPS_ARCH_32, "mips32"),
1334 ENUM_ENT(EF_MIPS_ARCH_64, "mips64"),
1335 ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"),
1336 ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"),
1337 ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"),
1338 ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6")
George Rimar47936762016-01-16 00:49:19 +00001339};
1340
Konstantin Zhuravlyovaa0835a2017-10-05 16:19:18 +00001341static const EnumEntry<unsigned> ElfHeaderAMDGPUFlags[] = {
Konstantin Zhuravlyov9122a632018-02-16 22:33:59 +00001342 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE),
1343 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600),
1344 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630),
1345 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880),
1346 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670),
1347 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710),
1348 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730),
1349 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770),
1350 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR),
1351 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS),
1352 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER),
1353 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD),
1354 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO),
1355 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS),
1356 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS),
1357 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN),
1358 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS),
1359 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600),
1360 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601),
1361 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700),
1362 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701),
1363 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702),
1364 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703),
1365 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704),
1366 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801),
1367 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802),
1368 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803),
1369 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810),
1370 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900),
1371 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902),
Matt Arsenault0084adc2018-04-30 19:08:16 +00001372 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904),
1373 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906),
Tim Renouf2a1b1d92018-10-24 08:14:07 +00001374 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909),
Konstantin Zhuravlyov108927b2018-11-05 22:44:19 +00001375 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_XNACK),
1376 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_SRAM_ECC)
Konstantin Zhuravlyovaa0835a2017-10-05 16:19:18 +00001377};
1378
Alex Bradburybb89b2b2017-10-03 08:41:59 +00001379static const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = {
Simon Atanasyan19932542018-10-25 05:39:27 +00001380 ENUM_ENT(EF_RISCV_RVC, "RVC"),
1381 ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"),
1382 ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"),
1383 ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"),
1384 ENUM_ENT(EF_RISCV_RVE, "RVE")
Alex Bradburybb89b2b2017-10-03 08:41:59 +00001385};
1386
Simon Atanasyanb7807a02016-03-24 16:10:37 +00001387static const EnumEntry<unsigned> ElfSymOtherFlags[] = {
1388 LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL),
1389 LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN),
1390 LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)
1391};
1392
1393static const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = {
1394 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
1395 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
1396 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC),
1397 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS)
1398};
1399
1400static const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = {
1401 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
1402 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
1403 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16)
1404};
1405
Simon Atanasyan8a71b532016-05-04 05:58:57 +00001406static const char *getElfMipsOptionsOdkType(unsigned Odk) {
1407 switch (Odk) {
1408 LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL);
1409 LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO);
1410 LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS);
1411 LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD);
1412 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH);
1413 LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL);
1414 LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS);
1415 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND);
1416 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR);
1417 LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP);
1418 LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT);
1419 LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE);
1420 default:
1421 return "Unknown";
1422 }
1423}
1424
George Rimar47936762016-01-16 00:49:19 +00001425template <typename ELFT>
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001426ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF,
1427 ScopedPrinter &Writer)
1428 : ObjDumper(Writer), ObjF(ObjF) {
George Rimar47936762016-01-16 00:49:19 +00001429 SmallVector<const Elf_Phdr *, 4> LoadSegments;
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001430 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Rafael Espindola6a494972016-11-03 17:28:33 +00001431 for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
George Rimar47936762016-01-16 00:49:19 +00001432 if (Phdr.p_type == ELF::PT_DYNAMIC) {
Rafael Espindolae17c3f32016-02-17 16:48:00 +00001433 DynamicTable = createDRIFrom(&Phdr, sizeof(Elf_Dyn));
George Rimar47936762016-01-16 00:49:19 +00001434 continue;
1435 }
1436 if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0)
1437 continue;
1438 LoadSegments.push_back(&Phdr);
1439 }
1440
Rafael Espindola25be8c82016-11-02 14:10:57 +00001441 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
Michael J. Spencer37304f12016-02-11 04:59:26 +00001442 switch (Sec.sh_type) {
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001443 case ELF::SHT_SYMTAB:
1444 if (DotSymtabSec != nullptr)
Saleem Abdulrasool46ee7332017-09-29 02:45:44 +00001445 reportError("Multiple SHT_SYMTAB");
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001446 DotSymtabSec = &Sec;
1447 break;
1448 case ELF::SHT_DYNSYM:
Rafael Espindolace2fbdd2016-02-17 15:38:21 +00001449 if (DynSymRegion.Size)
Saleem Abdulrasool46ee7332017-09-29 02:45:44 +00001450 reportError("Multiple SHT_DYNSYM");
Rafael Espindolace2fbdd2016-02-17 15:38:21 +00001451 DynSymRegion = createDRIFrom(&Sec);
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00001452 // This is only used (if Elf_Shdr present)for naming section in GNU style
1453 DynSymtabName = unwrapOrError(Obj->getSectionName(&Sec));
Dave Lee67b49662017-11-16 18:10:15 +00001454 DynamicStringTable = unwrapOrError(Obj->getStringTableForSymtab(Sec));
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001455 break;
Michael J. Spencer1c793ef2016-02-17 22:30:41 +00001456 case ELF::SHT_SYMTAB_SHNDX:
Rafael Espindolaf04f1842016-02-17 16:21:49 +00001457 ShndxTable = unwrapOrError(Obj->getSHNDXTable(Sec));
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001458 break;
Michael J. Spencer37304f12016-02-11 04:59:26 +00001459 case ELF::SHT_GNU_versym:
1460 if (dot_gnu_version_sec != nullptr)
1461 reportError("Multiple SHT_GNU_versym");
1462 dot_gnu_version_sec = &Sec;
1463 break;
1464 case ELF::SHT_GNU_verdef:
1465 if (dot_gnu_version_d_sec != nullptr)
1466 reportError("Multiple SHT_GNU_verdef");
1467 dot_gnu_version_d_sec = &Sec;
1468 break;
1469 case ELF::SHT_GNU_verneed:
1470 if (dot_gnu_version_r_sec != nullptr)
Saleem Abdulrasool46ee7332017-09-29 02:45:44 +00001471 reportError("Multiple SHT_GNU_verneed");
Michael J. Spencer37304f12016-02-11 04:59:26 +00001472 dot_gnu_version_r_sec = &Sec;
1473 break;
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00001474 case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
1475 if (DotCGProfileSec != nullptr)
Fangrui Song49c9ba12018-10-12 22:57:57 +00001476 reportError("Multiple .llvm.call-graph-profile");
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00001477 DotCGProfileSec = &Sec;
Peter Collingbourne3e227332018-07-17 22:17:18 +00001478 break;
1479 case ELF::SHT_LLVM_ADDRSIG:
1480 if (DotAddrsigSec != nullptr)
1481 reportError("Multiple .llvm_addrsig");
1482 DotAddrsigSec = &Sec;
1483 break;
Michael J. Spencer37304f12016-02-11 04:59:26 +00001484 }
1485 }
1486
Michael J. Spencer60d82b22016-02-11 04:59:37 +00001487 parseDynamicTable(LoadSegments);
1488
1489 if (opts::Output == opts::GNU)
Hemant Kulkarnic030f232016-03-15 17:25:31 +00001490 ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this));
Michael J. Spencer60d82b22016-02-11 04:59:37 +00001491 else
Hemant Kulkarnic030f232016-03-15 17:25:31 +00001492 ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this));
Michael J. Spencer60d82b22016-02-11 04:59:37 +00001493}
1494
1495template <typename ELFT>
1496void ELFDumper<ELFT>::parseDynamicTable(
1497 ArrayRef<const Elf_Phdr *> LoadSegments) {
George Rimar47936762016-01-16 00:49:19 +00001498 auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001499 auto MappedAddrOrError = ObjF->getELFFile()->toMappedAddr(VAddr);
Xing GUOfe5a6c32018-12-08 05:32:28 +00001500 if (!MappedAddrOrError)
1501 report_fatal_error(MappedAddrOrError.takeError());
1502 return MappedAddrOrError.get();
George Rimar47936762016-01-16 00:49:19 +00001503 };
1504
1505 uint64_t SONameOffset = 0;
1506 const char *StringTableBegin = nullptr;
1507 uint64_t StringTableSize = 0;
1508 for (const Elf_Dyn &Dyn : dynamic_table()) {
1509 switch (Dyn.d_tag) {
1510 case ELF::DT_HASH:
1511 HashTable =
1512 reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
1513 break;
1514 case ELF::DT_GNU_HASH:
1515 GnuHashTable =
1516 reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
1517 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001518 case ELF::DT_STRTAB:
1519 StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr());
Simon Atanasyan72155c32016-01-16 22:40:09 +00001520 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001521 case ELF::DT_STRSZ:
1522 StringTableSize = Dyn.getVal();
Simon Atanasyan72155c32016-01-16 22:40:09 +00001523 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001524 case ELF::DT_SYMTAB:
Rafael Espindolace2fbdd2016-02-17 15:38:21 +00001525 DynSymRegion.Addr = toMappedAddr(Dyn.getPtr());
1526 DynSymRegion.EntSize = sizeof(Elf_Sym);
Simon Atanasyan72155c32016-01-16 22:40:09 +00001527 break;
George Rimar47936762016-01-16 00:49:19 +00001528 case ELF::DT_RELA:
1529 DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
1530 break;
1531 case ELF::DT_RELASZ:
1532 DynRelaRegion.Size = Dyn.getVal();
1533 break;
1534 case ELF::DT_RELAENT:
1535 DynRelaRegion.EntSize = Dyn.getVal();
1536 break;
1537 case ELF::DT_SONAME:
1538 SONameOffset = Dyn.getVal();
1539 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001540 case ELF::DT_REL:
1541 DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
George Rimar47936762016-01-16 00:49:19 +00001542 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001543 case ELF::DT_RELSZ:
1544 DynRelRegion.Size = Dyn.getVal();
George Rimar47936762016-01-16 00:49:19 +00001545 break;
Michael J. Spencer94f060c2016-02-11 04:59:32 +00001546 case ELF::DT_RELENT:
1547 DynRelRegion.EntSize = Dyn.getVal();
George Rimar47936762016-01-16 00:49:19 +00001548 break;
Jake Ehrlich0f440d82018-06-28 21:07:34 +00001549 case ELF::DT_RELR:
1550 case ELF::DT_ANDROID_RELR:
1551 DynRelrRegion.Addr = toMappedAddr(Dyn.getPtr());
1552 break;
1553 case ELF::DT_RELRSZ:
1554 case ELF::DT_ANDROID_RELRSZ:
1555 DynRelrRegion.Size = Dyn.getVal();
1556 break;
1557 case ELF::DT_RELRENT:
1558 case ELF::DT_ANDROID_RELRENT:
1559 DynRelrRegion.EntSize = Dyn.getVal();
1560 break;
Rafael Espindola944f6552016-02-16 15:16:00 +00001561 case ELF::DT_PLTREL:
1562 if (Dyn.getVal() == DT_REL)
1563 DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
1564 else if (Dyn.getVal() == DT_RELA)
1565 DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
1566 else
1567 reportError(Twine("unknown DT_PLTREL value of ") +
1568 Twine((uint64_t)Dyn.getVal()));
1569 break;
1570 case ELF::DT_JMPREL:
1571 DynPLTRelRegion.Addr = toMappedAddr(Dyn.getPtr());
1572 break;
1573 case ELF::DT_PLTRELSZ:
1574 DynPLTRelRegion.Size = Dyn.getVal();
1575 break;
George Rimar47936762016-01-16 00:49:19 +00001576 }
1577 }
1578 if (StringTableBegin)
1579 DynamicStringTable = StringRef(StringTableBegin, StringTableSize);
1580 if (SONameOffset)
1581 SOName = getDynamicString(SONameOffset);
Rafael Espindola6009db62016-02-16 14:17:48 +00001582}
George Rimar47936762016-01-16 00:49:19 +00001583
Rafael Espindola6009db62016-02-16 14:17:48 +00001584template <typename ELFT>
Simon Atanasyan72155c32016-01-16 22:40:09 +00001585typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const {
Rafael Espindolaaafcf752016-04-05 14:47:22 +00001586 return DynRelRegion.getAsArrayRef<Elf_Rel>();
George Rimar47936762016-01-16 00:49:19 +00001587}
1588
1589template <typename ELFT>
1590typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
Rafael Espindolaaafcf752016-04-05 14:47:22 +00001591 return DynRelaRegion.getAsArrayRef<Elf_Rela>();
George Rimar47936762016-01-16 00:49:19 +00001592}
1593
Jake Ehrlich0f440d82018-06-28 21:07:34 +00001594template <typename ELFT>
1595typename ELFDumper<ELFT>::Elf_Relr_Range ELFDumper<ELFT>::dyn_relrs() const {
1596 return DynRelrRegion.getAsArrayRef<Elf_Relr>();
1597}
1598
George Rimar47936762016-01-16 00:49:19 +00001599template<class ELFT>
1600void ELFDumper<ELFT>::printFileHeaders() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001601 ELFDumperStyle->printFileHeaders(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001602}
1603
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001604template<class ELFT>
1605void ELFDumper<ELFT>::printSectionHeaders() {
1606 ELFDumperStyle->printSectionHeaders(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001607}
1608
1609template<class ELFT>
1610void ELFDumper<ELFT>::printRelocations() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001611 ELFDumperStyle->printRelocations(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001612}
1613
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001614template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001615 ELFDumperStyle->printProgramHeaders(ObjF->getELFFile());
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00001616}
1617
Simon Atanasyan72155c32016-01-16 22:40:09 +00001618template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001619 ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001620}
1621
George Rimar47936762016-01-16 00:49:19 +00001622template<class ELFT>
1623void ELFDumper<ELFT>::printSymbols() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001624 ELFDumperStyle->printSymbols(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001625}
1626
1627template<class ELFT>
1628void ELFDumper<ELFT>::printDynamicSymbols() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001629 ELFDumperStyle->printDynamicSymbols(ObjF->getELFFile());
George Rimar47936762016-01-16 00:49:19 +00001630}
1631
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +00001632template <class ELFT> void ELFDumper<ELFT>::printHashHistogram() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001633 ELFDumperStyle->printHashHistogram(ObjF->getELFFile());
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +00001634}
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00001635
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00001636template <class ELFT> void ELFDumper<ELFT>::printCGProfile() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001637 ELFDumperStyle->printCGProfile(ObjF->getELFFile());
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00001638}
1639
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00001640template <class ELFT> void ELFDumper<ELFT>::printNotes() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001641 ELFDumperStyle->printNotes(ObjF->getELFFile());
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00001642}
1643
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +00001644template <class ELFT> void ELFDumper<ELFT>::printELFLinkerOptions() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001645 ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile());
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +00001646}
1647
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001648static const char *getTypeString(unsigned Arch, uint64_t Type) {
Alexander Richardson3056a842018-03-21 14:17:50 +00001649#define DYNAMIC_TAG(n, v)
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001650 switch (Arch) {
1651 case EM_HEXAGON:
1652 switch (Type) {
Alexander Richardson3056a842018-03-21 14:17:50 +00001653#define HEXAGON_DYNAMIC_TAG(name, value) \
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001654 case DT_##name: \
1655 return #name;
Alexander Richardson3056a842018-03-21 14:17:50 +00001656#include "llvm/BinaryFormat/DynamicTags.def"
1657#undef HEXAGON_DYNAMIC_TAG
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001658 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001659 break;
Sean Fertileeaa16072018-04-13 16:42:48 +00001660
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001661 case EM_MIPS:
1662 switch (Type) {
Alexander Richardson3056a842018-03-21 14:17:50 +00001663#define MIPS_DYNAMIC_TAG(name, value) \
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001664 case DT_##name: \
1665 return #name;
Alexander Richardson3056a842018-03-21 14:17:50 +00001666#include "llvm/BinaryFormat/DynamicTags.def"
1667#undef MIPS_DYNAMIC_TAG
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001668 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001669 break;
Sean Fertileeaa16072018-04-13 16:42:48 +00001670
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001671 case EM_PPC64:
1672 switch(Type) {
Sean Fertileeaa16072018-04-13 16:42:48 +00001673#define PPC64_DYNAMIC_TAG(name, value) \
1674 case DT_##name: \
1675 return #name;
1676#include "llvm/BinaryFormat/DynamicTags.def"
1677#undef PPC64_DYNAMIC_TAG
1678 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00001679 break;
Hemant Kulkarnie60b2942016-12-27 19:59:29 +00001680 }
Alexander Richardson3056a842018-03-21 14:17:50 +00001681#undef DYNAMIC_TAG
George Rimar47936762016-01-16 00:49:19 +00001682 switch (Type) {
Alexander Richardson3056a842018-03-21 14:17:50 +00001683// Now handle all dynamic tags except the architecture specific ones
1684#define MIPS_DYNAMIC_TAG(name, value)
1685#define HEXAGON_DYNAMIC_TAG(name, value)
Sean Fertileeaa16072018-04-13 16:42:48 +00001686#define PPC64_DYNAMIC_TAG(name, value)
Alexander Richardson3056a842018-03-21 14:17:50 +00001687// Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
1688#define DYNAMIC_TAG_MARKER(name, value)
1689#define DYNAMIC_TAG(name, value) \
1690 case DT_##name: \
1691 return #name;
1692#include "llvm/BinaryFormat/DynamicTags.def"
1693#undef DYNAMIC_TAG
1694#undef MIPS_DYNAMIC_TAG
1695#undef HEXAGON_DYNAMIC_TAG
Sean Fertileeaa16072018-04-13 16:42:48 +00001696#undef PPC64_DYNAMIC_TAG
Alexander Richardson3056a842018-03-21 14:17:50 +00001697#undef DYNAMIC_TAG_MARKER
George Rimar47936762016-01-16 00:49:19 +00001698 default: return "unknown";
1699 }
1700}
1701
George Rimar47936762016-01-16 00:49:19 +00001702#define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
1703 { #enum, prefix##_##enum }
1704
1705static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
1706 LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
1707 LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
1708 LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
1709 LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
1710 LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
1711};
1712
1713static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
1714 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
1715 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
1716 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
1717 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
1718 LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
1719 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
1720 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
1721 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
1722 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
1723 LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
1724 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
1725 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
1726 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
1727 LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
1728 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
1729 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
1730 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
1731 LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
1732 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
1733 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
1734 LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
1735 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
1736 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
1737 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
1738 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
1739};
1740
1741static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
1742 LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
1743 LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
1744 LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
1745 LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
1746 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
1747 LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
1748 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
1749 LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
1750 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
1751 LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
1752 LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
1753 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
1754 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
1755 LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
1756 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
1757 LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
1758};
1759
1760#undef LLVM_READOBJ_DT_FLAG_ENT
1761
1762template <typename T, typename TFlag>
1763void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
Eugene Zelenko416e0592017-06-09 21:41:54 +00001764 using FlagEntry = EnumEntry<TFlag>;
1765 using FlagVector = SmallVector<FlagEntry, 10>;
George Rimar47936762016-01-16 00:49:19 +00001766 FlagVector SetFlags;
1767
1768 for (const auto &Flag : Flags) {
1769 if (Flag.Value == 0)
1770 continue;
1771
1772 if ((Value & Flag.Value) == Flag.Value)
1773 SetFlags.push_back(Flag);
1774 }
1775
1776 for (const auto &Flag : SetFlags) {
1777 OS << Flag.Name << " ";
1778 }
1779}
1780
1781template <class ELFT>
1782StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const {
1783 if (Value >= DynamicStringTable.size())
1784 reportError("Invalid dynamic string table reference");
1785 return StringRef(DynamicStringTable.data() + Value);
1786}
1787
George Rimarefd3ffb2017-07-14 16:00:16 +00001788static void printLibrary(raw_ostream &OS, const Twine &Tag, const Twine &Name) {
1789 OS << Tag << ": [" << Name << "]";
1790}
1791
George Rimar47936762016-01-16 00:49:19 +00001792template <class ELFT>
1793void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) {
1794 raw_ostream &OS = W.getOStream();
Hemant Kulkarnicb21f3c2016-05-12 22:16:53 +00001795 const char* ConvChar = (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64;
George Rimar47936762016-01-16 00:49:19 +00001796 switch (Type) {
1797 case DT_PLTREL:
1798 if (Value == DT_REL) {
1799 OS << "REL";
1800 break;
1801 } else if (Value == DT_RELA) {
1802 OS << "RELA";
1803 break;
1804 }
Justin Bognerb03fd122016-08-17 05:10:15 +00001805 LLVM_FALLTHROUGH;
George Rimar47936762016-01-16 00:49:19 +00001806 case DT_PLTGOT:
1807 case DT_HASH:
1808 case DT_STRTAB:
1809 case DT_SYMTAB:
1810 case DT_RELA:
1811 case DT_INIT:
1812 case DT_FINI:
1813 case DT_REL:
1814 case DT_JMPREL:
1815 case DT_INIT_ARRAY:
1816 case DT_FINI_ARRAY:
1817 case DT_PREINIT_ARRAY:
1818 case DT_DEBUG:
1819 case DT_VERDEF:
1820 case DT_VERNEED:
1821 case DT_VERSYM:
1822 case DT_GNU_HASH:
1823 case DT_NULL:
1824 case DT_MIPS_BASE_ADDRESS:
1825 case DT_MIPS_GOTSYM:
1826 case DT_MIPS_RLD_MAP:
1827 case DT_MIPS_RLD_MAP_REL:
1828 case DT_MIPS_PLTGOT:
1829 case DT_MIPS_OPTIONS:
Hemant Kulkarnicb21f3c2016-05-12 22:16:53 +00001830 OS << format(ConvChar, Value);
George Rimar47936762016-01-16 00:49:19 +00001831 break;
Davide Italiano8c503672016-01-16 06:06:36 +00001832 case DT_RELACOUNT:
George Rimar47936762016-01-16 00:49:19 +00001833 case DT_RELCOUNT:
1834 case DT_VERDEFNUM:
1835 case DT_VERNEEDNUM:
1836 case DT_MIPS_RLD_VERSION:
1837 case DT_MIPS_LOCAL_GOTNO:
1838 case DT_MIPS_SYMTABNO:
1839 case DT_MIPS_UNREFEXTNO:
1840 OS << Value;
1841 break;
1842 case DT_PLTRELSZ:
1843 case DT_RELASZ:
1844 case DT_RELAENT:
1845 case DT_STRSZ:
1846 case DT_SYMENT:
1847 case DT_RELSZ:
1848 case DT_RELENT:
1849 case DT_INIT_ARRAYSZ:
1850 case DT_FINI_ARRAYSZ:
1851 case DT_PREINIT_ARRAYSZ:
Peter Collingbourne5c54f152017-10-27 17:49:40 +00001852 case DT_ANDROID_RELSZ:
1853 case DT_ANDROID_RELASZ:
George Rimar47936762016-01-16 00:49:19 +00001854 OS << Value << " (bytes)";
1855 break;
1856 case DT_NEEDED:
George Rimarefd3ffb2017-07-14 16:00:16 +00001857 printLibrary(OS, "Shared library", getDynamicString(Value));
George Rimar47936762016-01-16 00:49:19 +00001858 break;
1859 case DT_SONAME:
George Rimarefd3ffb2017-07-14 16:00:16 +00001860 printLibrary(OS, "Library soname", getDynamicString(Value));
George Rimar47936762016-01-16 00:49:19 +00001861 break;
George Rimard8a4eca2016-09-02 07:35:19 +00001862 case DT_AUXILIARY:
George Rimarefd3ffb2017-07-14 16:00:16 +00001863 printLibrary(OS, "Auxiliary library", getDynamicString(Value));
1864 break;
1865 case DT_FILTER:
1866 printLibrary(OS, "Filter library", getDynamicString(Value));
George Rimard8a4eca2016-09-02 07:35:19 +00001867 break;
George Rimar47936762016-01-16 00:49:19 +00001868 case DT_RPATH:
1869 case DT_RUNPATH:
1870 OS << getDynamicString(Value);
1871 break;
1872 case DT_MIPS_FLAGS:
1873 printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1874 break;
1875 case DT_FLAGS:
1876 printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1877 break;
1878 case DT_FLAGS_1:
1879 printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1880 break;
1881 default:
Hemant Kulkarnicb21f3c2016-05-12 22:16:53 +00001882 OS << format(ConvChar, Value);
George Rimar47936762016-01-16 00:49:19 +00001883 break;
1884 }
1885}
1886
1887template<class ELFT>
1888void ELFDumper<ELFT>::printUnwindInfo() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001889 const unsigned Machine = ObjF->getELFFile()->getHeader()->e_machine;
Rafael Auler86fb7bf2018-03-08 00:46:53 +00001890 if (Machine == EM_386 || Machine == EM_X86_64) {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001891 DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF);
Rafael Auler86fb7bf2018-03-08 00:46:53 +00001892 return Ctx.printUnwindInformation();
1893 }
George Rimar47936762016-01-16 00:49:19 +00001894 W.startLine() << "UnwindInfo not implemented.\n";
1895}
1896
1897namespace {
Eugene Zelenko416e0592017-06-09 21:41:54 +00001898
Rui Ueyama1b31eb92018-01-12 01:40:32 +00001899template <> void ELFDumper<ELF32LE>::printUnwindInfo() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001900 const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
George Rimar47936762016-01-16 00:49:19 +00001901 const unsigned Machine = Obj->getHeader()->e_machine;
1902 if (Machine == EM_ARM) {
Rui Ueyama1b31eb92018-01-12 01:40:32 +00001903 ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, DotSymtabSec);
George Rimar47936762016-01-16 00:49:19 +00001904 return Ctx.PrintUnwindInformation();
1905 }
1906 W.startLine() << "UnwindInfo not implemented.\n";
1907}
Eugene Zelenko416e0592017-06-09 21:41:54 +00001908
1909} // end anonymous namespace
George Rimar47936762016-01-16 00:49:19 +00001910
1911template<class ELFT>
1912void ELFDumper<ELFT>::printDynamicTable() {
Rafael Espindolae17c3f32016-02-17 16:48:00 +00001913 auto I = dynamic_table().begin();
1914 auto E = dynamic_table().end();
George Rimar47936762016-01-16 00:49:19 +00001915
1916 if (I == E)
1917 return;
1918
1919 --E;
1920 while (I != E && E->getTag() == ELF::DT_NULL)
1921 --E;
1922 if (E->getTag() != ELF::DT_NULL)
1923 ++E;
1924 ++E;
1925
1926 ptrdiff_t Total = std::distance(I, E);
1927 if (Total == 0)
1928 return;
1929
1930 raw_ostream &OS = W.getOStream();
1931 W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1932
1933 bool Is64 = ELFT::Is64Bits;
1934
1935 W.startLine()
1936 << " Tag" << (Is64 ? " " : " ") << "Type"
1937 << " " << "Name/Value\n";
1938 while (I != E) {
1939 const Elf_Dyn &Entry = *I;
1940 uintX_t Tag = Entry.getTag();
1941 ++I;
Hemant Kulkarnicb21f3c2016-05-12 22:16:53 +00001942 W.startLine() << " " << format_hex(Tag, Is64 ? 18 : 10, opts::Output != opts::GNU) << " "
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001943 << format("%-21s", getTypeString(ObjF->getELFFile()->getHeader()->e_machine, Tag));
George Rimar47936762016-01-16 00:49:19 +00001944 printValue(Tag, Entry.getVal());
1945 OS << "\n";
1946 }
1947
1948 W.startLine() << "]\n";
1949}
1950
1951template<class ELFT>
1952void ELFDumper<ELFT>::printNeededLibraries() {
1953 ListScope D(W, "NeededLibraries");
1954
Eugene Zelenko416e0592017-06-09 21:41:54 +00001955 using LibsTy = std::vector<StringRef>;
George Rimar47936762016-01-16 00:49:19 +00001956 LibsTy Libs;
1957
1958 for (const auto &Entry : dynamic_table())
1959 if (Entry.d_tag == ELF::DT_NEEDED)
1960 Libs.push_back(getDynamicString(Entry.d_un.d_val));
1961
1962 std::stable_sort(Libs.begin(), Libs.end());
1963
Sam Clegg88e9a152018-01-10 00:14:19 +00001964 for (const auto &L : Libs)
1965 W.startLine() << L << "\n";
George Rimar47936762016-01-16 00:49:19 +00001966}
1967
George Rimar47936762016-01-16 00:49:19 +00001968
1969template <typename ELFT>
1970void ELFDumper<ELFT>::printHashTable() {
1971 DictScope D(W, "HashTable");
1972 if (!HashTable)
1973 return;
1974 W.printNumber("Num Buckets", HashTable->nbucket);
1975 W.printNumber("Num Chains", HashTable->nchain);
1976 W.printList("Buckets", HashTable->buckets());
1977 W.printList("Chains", HashTable->chains());
1978}
1979
1980template <typename ELFT>
1981void ELFDumper<ELFT>::printGnuHashTable() {
1982 DictScope D(W, "GnuHashTable");
1983 if (!GnuHashTable)
1984 return;
1985 W.printNumber("Num Buckets", GnuHashTable->nbuckets);
1986 W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
1987 W.printNumber("Num Mask Words", GnuHashTable->maskwords);
1988 W.printNumber("Shift Count", GnuHashTable->shift2);
1989 W.printHexList("Bloom Filter", GnuHashTable->filter());
1990 W.printList("Buckets", GnuHashTable->buckets());
Rafael Espindolace2fbdd2016-02-17 15:38:21 +00001991 Elf_Sym_Range Syms = dynamic_symbols();
1992 unsigned NumSyms = std::distance(Syms.begin(), Syms.end());
1993 if (!NumSyms)
George Rimar47936762016-01-16 00:49:19 +00001994 reportError("No dynamic symbol section");
Rafael Espindolace2fbdd2016-02-17 15:38:21 +00001995 W.printHexList("Values", GnuHashTable->values(NumSyms));
George Rimar47936762016-01-16 00:49:19 +00001996}
1997
1998template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
Sam Clegg88e9a152018-01-10 00:14:19 +00001999 W.printString("LoadName", SOName);
George Rimar47936762016-01-16 00:49:19 +00002000}
2001
2002template <class ELFT>
2003void ELFDumper<ELFT>::printAttributes() {
2004 W.startLine() << "Attributes not implemented.\n";
2005}
2006
2007namespace {
Eugene Zelenko416e0592017-06-09 21:41:54 +00002008
Rui Ueyama1b31eb92018-01-12 01:40:32 +00002009template <> void ELFDumper<ELF32LE>::printAttributes() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002010 const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
George Rimar47936762016-01-16 00:49:19 +00002011 if (Obj->getHeader()->e_machine != EM_ARM) {
2012 W.startLine() << "Attributes not implemented.\n";
2013 return;
2014 }
2015
2016 DictScope BA(W, "BuildAttributes");
Rafael Espindola25be8c82016-11-02 14:10:57 +00002017 for (const ELFO::Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
George Rimar47936762016-01-16 00:49:19 +00002018 if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
2019 continue;
2020
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002021 ArrayRef<uint8_t> Contents = unwrapOrError(Obj->getSectionContents(&Sec));
2022 if (Contents[0] != ARMBuildAttrs::Format_Version) {
Benjamin Kramer3a13ed62017-12-28 16:58:54 +00002023 errs() << "unrecognised FormatVersion: 0x"
2024 << Twine::utohexstr(Contents[0]) << '\n';
George Rimar47936762016-01-16 00:49:19 +00002025 continue;
2026 }
2027
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002028 W.printHex("FormatVersion", Contents[0]);
2029 if (Contents.size() == 1)
George Rimar47936762016-01-16 00:49:19 +00002030 continue;
2031
Sam Parkerdf7c6ef2017-01-18 13:52:12 +00002032 ARMAttributeParser(&W).Parse(Contents, true);
George Rimar47936762016-01-16 00:49:19 +00002033 }
2034}
George Rimar47936762016-01-16 00:49:19 +00002035
George Rimar47936762016-01-16 00:49:19 +00002036template <class ELFT> class MipsGOTParser {
2037public:
Rafael Espindola6bc29902016-10-06 14:07:26 +00002038 TYPEDEF_ELF_TYPES(ELFT)
Simon Atanasyan62d32592017-12-21 10:26:02 +00002039 using Entry = typename ELFO::Elf_Addr;
2040 using Entries = ArrayRef<Entry>;
Eugene Zelenko416e0592017-06-09 21:41:54 +00002041
Simon Atanasyan62d32592017-12-21 10:26:02 +00002042 const bool IsStatic;
2043 const ELFO * const Obj;
George Rimar47936762016-01-16 00:49:19 +00002044
Simon Atanasyan62d32592017-12-21 10:26:02 +00002045 MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms);
2046
2047 bool hasGot() const { return !GotEntries.empty(); }
2048 bool hasPlt() const { return !PltEntries.empty(); }
2049
2050 uint64_t getGp() const;
2051
2052 const Entry *getGotLazyResolver() const;
2053 const Entry *getGotModulePointer() const;
2054 const Entry *getPltLazyResolver() const;
2055 const Entry *getPltModulePointer() const;
2056
2057 Entries getLocalEntries() const;
2058 Entries getGlobalEntries() const;
2059 Entries getOtherEntries() const;
2060 Entries getPltEntries() const;
2061
2062 uint64_t getGotAddress(const Entry * E) const;
2063 int64_t getGotOffset(const Entry * E) const;
2064 const Elf_Sym *getGotSym(const Entry *E) const;
2065
2066 uint64_t getPltAddress(const Entry * E) const;
2067 const Elf_Sym *getPltSym(const Entry *E) const;
2068
2069 StringRef getPltStrTable() const { return PltStrTable; }
George Rimar47936762016-01-16 00:49:19 +00002070
2071private:
Simon Atanasyan62d32592017-12-21 10:26:02 +00002072 const Elf_Shdr *GotSec;
2073 size_t LocalNum;
2074 size_t GlobalNum;
George Rimar47936762016-01-16 00:49:19 +00002075
Simon Atanasyan62d32592017-12-21 10:26:02 +00002076 const Elf_Shdr *PltSec;
2077 const Elf_Shdr *PltRelSec;
2078 const Elf_Shdr *PltSymTable;
2079 Elf_Sym_Range GotDynSyms;
2080 StringRef PltStrTable;
George Rimar47936762016-01-16 00:49:19 +00002081
Simon Atanasyan62d32592017-12-21 10:26:02 +00002082 Entries GotEntries;
2083 Entries PltEntries;
George Rimar47936762016-01-16 00:49:19 +00002084};
Eugene Zelenko416e0592017-06-09 21:41:54 +00002085
2086} // end anonymous namespace
George Rimar47936762016-01-16 00:49:19 +00002087
2088template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002089MipsGOTParser<ELFT>::MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable,
2090 Elf_Sym_Range DynSyms)
2091 : IsStatic(DynTable.empty()), Obj(Obj), GotSec(nullptr), LocalNum(0),
2092 GlobalNum(0), PltSec(nullptr), PltRelSec(nullptr), PltSymTable(nullptr) {
2093 // See "Global Offset Table" in Chapter 5 in the following document
2094 // for detailed GOT description.
2095 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
2096
2097 // Find static GOT secton.
2098 if (IsStatic) {
2099 GotSec = findSectionByName(*Obj, ".got");
2100 if (!GotSec)
2101 reportError("Cannot find .got section");
2102
2103 ArrayRef<uint8_t> Content = unwrapOrError(Obj->getSectionContents(GotSec));
2104 GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
2105 Content.size() / sizeof(Entry));
2106 LocalNum = GotEntries.size();
2107 return;
2108 }
2109
2110 // Lookup dynamic table tags which define GOT/PLT layouts.
2111 Optional<uint64_t> DtPltGot;
2112 Optional<uint64_t> DtLocalGotNum;
2113 Optional<uint64_t> DtGotSym;
2114 Optional<uint64_t> DtMipsPltGot;
2115 Optional<uint64_t> DtJmpRel;
George Rimar47936762016-01-16 00:49:19 +00002116 for (const auto &Entry : DynTable) {
2117 switch (Entry.getTag()) {
2118 case ELF::DT_PLTGOT:
2119 DtPltGot = Entry.getVal();
2120 break;
2121 case ELF::DT_MIPS_LOCAL_GOTNO:
2122 DtLocalGotNum = Entry.getVal();
2123 break;
2124 case ELF::DT_MIPS_GOTSYM:
2125 DtGotSym = Entry.getVal();
2126 break;
2127 case ELF::DT_MIPS_PLTGOT:
2128 DtMipsPltGot = Entry.getVal();
2129 break;
2130 case ELF::DT_JMPREL:
2131 DtJmpRel = Entry.getVal();
2132 break;
2133 }
2134 }
Simon Atanasyan62d32592017-12-21 10:26:02 +00002135
2136 // Find dynamic GOT section.
2137 if (DtPltGot || DtLocalGotNum || DtGotSym) {
2138 if (!DtPltGot)
2139 report_fatal_error("Cannot find PLTGOT dynamic table tag.");
2140 if (!DtLocalGotNum)
2141 report_fatal_error("Cannot find MIPS_LOCAL_GOTNO dynamic table tag.");
2142 if (!DtGotSym)
2143 report_fatal_error("Cannot find MIPS_GOTSYM dynamic table tag.");
2144
2145 size_t DynSymTotal = DynSyms.size();
2146 if (*DtGotSym > DynSymTotal)
2147 reportError("MIPS_GOTSYM exceeds a number of dynamic symbols");
2148
2149 GotSec = findNotEmptySectionByAddress(Obj, *DtPltGot);
2150 if (!GotSec)
2151 reportError("There is no not empty GOT section at 0x" +
2152 Twine::utohexstr(*DtPltGot));
2153
2154 LocalNum = *DtLocalGotNum;
2155 GlobalNum = DynSymTotal - *DtGotSym;
2156
2157 ArrayRef<uint8_t> Content = unwrapOrError(Obj->getSectionContents(GotSec));
2158 GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
2159 Content.size() / sizeof(Entry));
2160 GotDynSyms = DynSyms.drop_front(*DtGotSym);
2161 }
2162
2163 // Find PLT section.
2164 if (DtMipsPltGot || DtJmpRel) {
2165 if (!DtMipsPltGot)
2166 report_fatal_error("Cannot find MIPS_PLTGOT dynamic table tag.");
2167 if (!DtJmpRel)
2168 report_fatal_error("Cannot find JMPREL dynamic table tag.");
2169
2170 PltSec = findNotEmptySectionByAddress(Obj, *DtMipsPltGot);
2171 if (!PltSec)
2172 report_fatal_error("There is no not empty PLTGOT section at 0x " +
2173 Twine::utohexstr(*DtMipsPltGot));
2174
2175 PltRelSec = findNotEmptySectionByAddress(Obj, *DtJmpRel);
2176 if (!PltRelSec)
2177 report_fatal_error("There is no not empty RELPLT section at 0x" +
2178 Twine::utohexstr(*DtJmpRel));
2179
2180 ArrayRef<uint8_t> PltContent =
2181 unwrapOrError(Obj->getSectionContents(PltSec));
2182 PltEntries = Entries(reinterpret_cast<const Entry *>(PltContent.data()),
2183 PltContent.size() / sizeof(Entry));
2184
2185 PltSymTable = unwrapOrError(Obj->getSection(PltRelSec->sh_link));
2186 PltStrTable = unwrapOrError(Obj->getStringTableForSymtab(*PltSymTable));
2187 }
2188}
2189
2190template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const {
2191 return GotSec->sh_addr + 0x7ff0;
George Rimar47936762016-01-16 00:49:19 +00002192}
2193
Simon Atanasyand4b693b2017-12-02 13:06:35 +00002194template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002195const typename MipsGOTParser<ELFT>::Entry *
2196MipsGOTParser<ELFT>::getGotLazyResolver() const {
2197 return LocalNum > 0 ? &GotEntries[0] : nullptr;
George Rimar47936762016-01-16 00:49:19 +00002198}
2199
2200template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002201const typename MipsGOTParser<ELFT>::Entry *
2202MipsGOTParser<ELFT>::getGotModulePointer() const {
2203 if (LocalNum < 2)
2204 return nullptr;
2205 const Entry &E = GotEntries[1];
2206 if ((E >> (sizeof(Entry) * 8 - 1)) == 0)
2207 return nullptr;
2208 return &E;
George Rimar47936762016-01-16 00:49:19 +00002209}
2210
2211template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002212typename MipsGOTParser<ELFT>::Entries
2213MipsGOTParser<ELFT>::getLocalEntries() const {
2214 size_t Skip = getGotModulePointer() ? 2 : 1;
2215 if (LocalNum - Skip <= 0)
2216 return Entries();
2217 return GotEntries.slice(Skip, LocalNum - Skip);
George Rimar47936762016-01-16 00:49:19 +00002218}
2219
2220template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002221typename MipsGOTParser<ELFT>::Entries
2222MipsGOTParser<ELFT>::getGlobalEntries() const {
2223 if (GlobalNum == 0)
2224 return Entries();
2225 return GotEntries.slice(LocalNum, GlobalNum);
George Rimar47936762016-01-16 00:49:19 +00002226}
2227
2228template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002229typename MipsGOTParser<ELFT>::Entries
2230MipsGOTParser<ELFT>::getOtherEntries() const {
2231 size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum;
2232 if (OtherNum == 0)
2233 return Entries();
2234 return GotEntries.slice(LocalNum + GlobalNum, OtherNum);
George Rimar47936762016-01-16 00:49:19 +00002235}
2236
2237template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002238uint64_t MipsGOTParser<ELFT>::getGotAddress(const Entry *E) const {
2239 int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry);
2240 return GotSec->sh_addr + Offset;
George Rimar47936762016-01-16 00:49:19 +00002241}
2242
2243template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00002244int64_t MipsGOTParser<ELFT>::getGotOffset(const Entry *E) const {
2245 int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry);
2246 return Offset - 0x7ff0;
2247}
George Rimar47936762016-01-16 00:49:19 +00002248
Simon Atanasyan62d32592017-12-21 10:26:02 +00002249template <class ELFT>
2250const typename MipsGOTParser<ELFT>::Elf_Sym *
2251MipsGOTParser<ELFT>::getGotSym(const Entry *E) const {
2252 int64_t Offset = std::distance(GotEntries.data(), E);
2253 return &GotDynSyms[Offset - LocalNum];
2254}
George Rimar47936762016-01-16 00:49:19 +00002255
Simon Atanasyan62d32592017-12-21 10:26:02 +00002256template <class ELFT>
2257const typename MipsGOTParser<ELFT>::Entry *
2258MipsGOTParser<ELFT>::getPltLazyResolver() const {
2259 return PltEntries.empty() ? nullptr : &PltEntries[0];
2260}
2261
2262template <class ELFT>
2263const typename MipsGOTParser<ELFT>::Entry *
2264MipsGOTParser<ELFT>::getPltModulePointer() const {
2265 return PltEntries.size() < 2 ? nullptr : &PltEntries[1];
2266}
2267
2268template <class ELFT>
2269typename MipsGOTParser<ELFT>::Entries
2270MipsGOTParser<ELFT>::getPltEntries() const {
2271 if (PltEntries.size() <= 2)
2272 return Entries();
2273 return PltEntries.slice(2, PltEntries.size() - 2);
2274}
2275
2276template <class ELFT>
2277uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const {
2278 int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry);
2279 return PltSec->sh_addr + Offset;
2280}
2281
2282template <class ELFT>
2283const typename MipsGOTParser<ELFT>::Elf_Sym *
2284MipsGOTParser<ELFT>::getPltSym(const Entry *E) const {
2285 int64_t Offset = std::distance(getPltEntries().data(), E);
2286 if (PltRelSec->sh_type == ELF::SHT_REL) {
2287 Elf_Rel_Range Rels = unwrapOrError(Obj->rels(PltRelSec));
2288 return unwrapOrError(Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
2289 } else {
2290 Elf_Rela_Range Rels = unwrapOrError(Obj->relas(PltRelSec));
2291 return unwrapOrError(Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
2292 }
George Rimar47936762016-01-16 00:49:19 +00002293}
2294
2295template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002296 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Simon Atanasyan62d32592017-12-21 10:26:02 +00002297 if (Obj->getHeader()->e_machine != EM_MIPS)
2298 reportError("MIPS PLT GOT is available for MIPS targets only");
George Rimar47936762016-01-16 00:49:19 +00002299
Simon Atanasyan62d32592017-12-21 10:26:02 +00002300 MipsGOTParser<ELFT> Parser(Obj, dynamic_table(), dynamic_symbols());
2301 if (Parser.hasGot())
2302 ELFDumperStyle->printMipsGOT(Parser);
2303 if (Parser.hasPlt())
2304 ELFDumperStyle->printMipsPLT(Parser);
George Rimar47936762016-01-16 00:49:19 +00002305}
2306
2307static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
2308 {"None", Mips::AFL_EXT_NONE},
2309 {"Broadcom SB-1", Mips::AFL_EXT_SB1},
2310 {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON},
2311 {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
2312 {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
2313 {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
2314 {"LSI R4010", Mips::AFL_EXT_4010},
2315 {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E},
2316 {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F},
2317 {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A},
2318 {"MIPS R4650", Mips::AFL_EXT_4650},
2319 {"MIPS R5900", Mips::AFL_EXT_5900},
2320 {"MIPS R10000", Mips::AFL_EXT_10000},
2321 {"NEC VR4100", Mips::AFL_EXT_4100},
2322 {"NEC VR4111/VR4181", Mips::AFL_EXT_4111},
2323 {"NEC VR4120", Mips::AFL_EXT_4120},
2324 {"NEC VR5400", Mips::AFL_EXT_5400},
2325 {"NEC VR5500", Mips::AFL_EXT_5500},
2326 {"RMI Xlr", Mips::AFL_EXT_XLR},
2327 {"Toshiba R3900", Mips::AFL_EXT_3900}
2328};
2329
2330static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
2331 {"DSP", Mips::AFL_ASE_DSP},
2332 {"DSPR2", Mips::AFL_ASE_DSPR2},
2333 {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
2334 {"MCU", Mips::AFL_ASE_MCU},
2335 {"MDMX", Mips::AFL_ASE_MDMX},
2336 {"MIPS-3D", Mips::AFL_ASE_MIPS3D},
2337 {"MT", Mips::AFL_ASE_MT},
2338 {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS},
2339 {"VZ", Mips::AFL_ASE_VIRT},
2340 {"MSA", Mips::AFL_ASE_MSA},
2341 {"MIPS16", Mips::AFL_ASE_MIPS16},
2342 {"microMIPS", Mips::AFL_ASE_MICROMIPS},
Petar Jovanovic3408caf2018-03-14 14:13:31 +00002343 {"XPA", Mips::AFL_ASE_XPA},
2344 {"CRC", Mips::AFL_ASE_CRC},
Petar Jovanovicdaf51692018-05-17 16:30:32 +00002345 {"GINV", Mips::AFL_ASE_GINV},
George Rimar47936762016-01-16 00:49:19 +00002346};
2347
2348static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
2349 {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY},
2350 {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
2351 {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
2352 {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT},
2353 {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
2354 Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
2355 {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX},
2356 {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
2357 {"Hard float compat (32-bit CPU, 64-bit FPU)",
2358 Mips::Val_GNU_MIPS_ABI_FP_64A}
2359};
2360
2361static const EnumEntry<unsigned> ElfMipsFlags1[] {
2362 {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
2363};
2364
2365static int getMipsRegisterSize(uint8_t Flag) {
2366 switch (Flag) {
2367 case Mips::AFL_REG_NONE:
2368 return 0;
2369 case Mips::AFL_REG_32:
2370 return 32;
2371 case Mips::AFL_REG_64:
2372 return 64;
2373 case Mips::AFL_REG_128:
2374 return 128;
2375 default:
2376 return -1;
2377 }
2378}
2379
2380template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002381 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
George Rimar47936762016-01-16 00:49:19 +00002382 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
2383 if (!Shdr) {
2384 W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
2385 return;
2386 }
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002387 ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2388 if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
George Rimar47936762016-01-16 00:49:19 +00002389 W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
2390 return;
2391 }
2392
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002393 auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data());
George Rimar47936762016-01-16 00:49:19 +00002394
2395 raw_ostream &OS = W.getOStream();
2396 DictScope GS(W, "MIPS ABI Flags");
2397
2398 W.printNumber("Version", Flags->version);
2399 W.startLine() << "ISA: ";
2400 if (Flags->isa_rev <= 1)
2401 OS << format("MIPS%u", Flags->isa_level);
2402 else
2403 OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
2404 OS << "\n";
2405 W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
2406 W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
2407 W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
2408 W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
2409 W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
2410 W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
2411 W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
2412 W.printHex("Flags 2", Flags->flags2);
2413}
2414
Simon Atanasyan8a71b532016-05-04 05:58:57 +00002415template <class ELFT>
2416static void printMipsReginfoData(ScopedPrinter &W,
2417 const Elf_Mips_RegInfo<ELFT> &Reginfo) {
2418 W.printHex("GP", Reginfo.ri_gp_value);
2419 W.printHex("General Mask", Reginfo.ri_gprmask);
2420 W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]);
2421 W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]);
2422 W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]);
2423 W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]);
2424}
2425
George Rimar47936762016-01-16 00:49:19 +00002426template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002427 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
George Rimar47936762016-01-16 00:49:19 +00002428 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
2429 if (!Shdr) {
2430 W.startLine() << "There is no .reginfo section in the file.\n";
2431 return;
2432 }
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002433 ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2434 if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
George Rimar47936762016-01-16 00:49:19 +00002435 W.startLine() << "The .reginfo section has a wrong size.\n";
2436 return;
2437 }
2438
George Rimar47936762016-01-16 00:49:19 +00002439 DictScope GS(W, "MIPS RegInfo");
Simon Atanasyan8a71b532016-05-04 05:58:57 +00002440 auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data());
2441 printMipsReginfoData(W, *Reginfo);
2442}
2443
2444template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002445 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Simon Atanasyan8a71b532016-05-04 05:58:57 +00002446 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.options");
2447 if (!Shdr) {
2448 W.startLine() << "There is no .MIPS.options section in the file.\n";
2449 return;
2450 }
2451
2452 DictScope GS(W, "MIPS Options");
2453
2454 ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2455 while (!Sec.empty()) {
2456 if (Sec.size() < sizeof(Elf_Mips_Options<ELFT>)) {
2457 W.startLine() << "The .MIPS.options section has a wrong size.\n";
2458 return;
2459 }
2460 auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(Sec.data());
2461 DictScope GS(W, getElfMipsOptionsOdkType(O->kind));
2462 switch (O->kind) {
2463 case ODK_REGINFO:
2464 printMipsReginfoData(W, O->getRegInfo());
2465 break;
2466 default:
2467 W.startLine() << "Unsupported MIPS options tag.\n";
2468 break;
2469 }
2470 Sec = Sec.slice(O->size);
2471 }
George Rimar47936762016-01-16 00:49:19 +00002472}
2473
2474template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002475 const ELFFile<ELFT> *Obj = ObjF->getELFFile();
George Rimar47936762016-01-16 00:49:19 +00002476 const Elf_Shdr *StackMapSection = nullptr;
Rafael Espindola25be8c82016-11-02 14:10:57 +00002477 for (const auto &Sec : unwrapOrError(Obj->sections())) {
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002478 StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2479 if (Name == ".llvm_stackmaps") {
George Rimar47936762016-01-16 00:49:19 +00002480 StackMapSection = &Sec;
2481 break;
2482 }
2483 }
2484
2485 if (!StackMapSection)
2486 return;
2487
Rafael Espindolaf04f1842016-02-17 16:21:49 +00002488 ArrayRef<uint8_t> StackMapContentsArray =
2489 unwrapOrError(Obj->getSectionContents(StackMapSection));
George Rimar47936762016-01-16 00:49:19 +00002490
Sam Clegg88e9a152018-01-10 00:14:19 +00002491 prettyPrintStackMap(
2492 W, StackMapV2Parser<ELFT::TargetEndianness>(StackMapContentsArray));
George Rimar47936762016-01-16 00:49:19 +00002493}
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002494
Hemant Kulkarniab4a46f2016-01-26 19:46:39 +00002495template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002496 ELFDumperStyle->printGroupSections(ObjF->getELFFile());
Hemant Kulkarniab4a46f2016-01-26 19:46:39 +00002497}
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002498
Peter Collingbourne3e227332018-07-17 22:17:18 +00002499template <class ELFT> void ELFDumper<ELFT>::printAddrsig() {
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002500 ELFDumperStyle->printAddrsig(ObjF->getELFFile());
Peter Collingbourne3e227332018-07-17 22:17:18 +00002501}
2502
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002503static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
2504 StringRef Str2) {
2505 OS.PadToColumn(2u);
2506 OS << Str1;
2507 OS.PadToColumn(37u);
2508 OS << Str2 << "\n";
2509 OS.flush();
2510}
2511
George Rimar6fdac3b2018-07-18 08:19:58 +00002512template <class ELFT>
2513static std::string getSectionHeadersNumString(const ELFFile<ELFT> *Obj) {
2514 const typename ELFT::Ehdr *ElfHeader = Obj->getHeader();
2515 if (ElfHeader->e_shnum != 0)
2516 return to_string(ElfHeader->e_shnum);
2517
2518 ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError(Obj->sections());
2519 if (Arr.empty())
2520 return "0";
2521 return "0 (" + to_string(Arr[0].sh_size) + ")";
2522}
2523
2524template <class ELFT>
2525static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> *Obj) {
2526 const typename ELFT::Ehdr *ElfHeader = Obj->getHeader();
2527 if (ElfHeader->e_shstrndx != SHN_XINDEX)
2528 return to_string(ElfHeader->e_shstrndx);
2529
2530 ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError(Obj->sections());
2531 if (Arr.empty())
2532 return "65535 (corrupt: out of range)";
2533 return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) + ")";
2534}
2535
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002536template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002537 const Elf_Ehdr *e = Obj->getHeader();
2538 OS << "ELF Header:\n";
2539 OS << " Magic: ";
2540 std::string Str;
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002541 for (int i = 0; i < ELF::EI_NIDENT; i++)
2542 OS << format(" %02x", static_cast<int>(e->e_ident[i]));
2543 OS << "\n";
2544 Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002545 printFields(OS, "Class:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002546 Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002547 printFields(OS, "Data:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002548 OS.PadToColumn(2u);
2549 OS << "Version:";
2550 OS.PadToColumn(37u);
2551 OS << to_hexString(e->e_ident[ELF::EI_VERSION]);
2552 if (e->e_version == ELF::EV_CURRENT)
2553 OS << " (current)";
2554 OS << "\n";
2555 Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002556 printFields(OS, "OS/ABI:", Str);
Chandler Carruthe8fa5ae2016-11-03 17:11:11 +00002557 Str = "0x" + to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002558 printFields(OS, "ABI Version:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002559 Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType));
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002560 printFields(OS, "Type:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002561 Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType));
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002562 printFields(OS, "Machine:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002563 Str = "0x" + to_hexString(e->e_version);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002564 printFields(OS, "Version:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002565 Str = "0x" + to_hexString(e->e_entry);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002566 printFields(OS, "Entry point address:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002567 Str = to_string(e->e_phoff) + " (bytes into file)";
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002568 printFields(OS, "Start of program headers:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002569 Str = to_string(e->e_shoff) + " (bytes into file)";
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002570 printFields(OS, "Start of section headers:", Str);
Simon Atanasyan19932542018-10-25 05:39:27 +00002571 std::string ElfFlags;
2572 if (e->e_machine == EM_MIPS)
2573 ElfFlags =
2574 printFlags(e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
2575 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
2576 unsigned(ELF::EF_MIPS_MACH));
2577 else if (e->e_machine == EM_RISCV)
2578 ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderRISCVFlags));
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002579 Str = "0x" + to_hexString(e->e_flags);
Simon Atanasyan19932542018-10-25 05:39:27 +00002580 if (!ElfFlags.empty())
2581 Str = Str + ", " + ElfFlags;
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002582 printFields(OS, "Flags:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002583 Str = to_string(e->e_ehsize) + " (bytes)";
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002584 printFields(OS, "Size of this header:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002585 Str = to_string(e->e_phentsize) + " (bytes)";
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002586 printFields(OS, "Size of program headers:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002587 Str = to_string(e->e_phnum);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002588 printFields(OS, "Number of program headers:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002589 Str = to_string(e->e_shentsize) + " (bytes)";
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002590 printFields(OS, "Size of section headers:", Str);
George Rimar6fdac3b2018-07-18 08:19:58 +00002591 Str = getSectionHeadersNumString(Obj);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002592 printFields(OS, "Number of section headers:", Str);
George Rimar6fdac3b2018-07-18 08:19:58 +00002593 Str = getSectionHeaderTableIndexString(Obj);
Hemant Kulkarnif84cda72016-02-11 03:41:34 +00002594 printFields(OS, "Section header string table index:", Str);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002595}
2596
George Rimarea39eed2017-09-14 07:32:52 +00002597namespace {
2598struct GroupMember {
2599 StringRef Name;
2600 uint64_t Index;
2601};
2602
2603struct GroupSection {
2604 StringRef Name;
James Hendersone50d9cb2019-01-17 15:34:12 +00002605 std::string Signature;
George Rimarea39eed2017-09-14 07:32:52 +00002606 uint64_t ShName;
2607 uint64_t Index;
Alexander Shaposhnikov8febe3d2018-03-12 22:40:09 +00002608 uint32_t Link;
2609 uint32_t Info;
George Rimarea39eed2017-09-14 07:32:52 +00002610 uint32_t Type;
2611 std::vector<GroupMember> Members;
2612};
2613
2614template <class ELFT>
2615std::vector<GroupSection> getGroups(const ELFFile<ELFT> *Obj) {
Rui Ueyama478d6352018-01-12 02:28:31 +00002616 using Elf_Shdr = typename ELFT::Shdr;
2617 using Elf_Sym = typename ELFT::Sym;
2618 using Elf_Word = typename ELFT::Word;
George Rimarea39eed2017-09-14 07:32:52 +00002619
2620 std::vector<GroupSection> Ret;
2621 uint64_t I = 0;
George Rimar3c0f3962017-09-14 07:26:14 +00002622 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
George Rimarea39eed2017-09-14 07:32:52 +00002623 ++I;
2624 if (Sec.sh_type != ELF::SHT_GROUP)
2625 continue;
2626
2627 const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
2628 StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
2629 const Elf_Sym *Sym =
2630 unwrapOrError(Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info));
2631 auto Data =
2632 unwrapOrError(Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
2633
2634 StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2635 StringRef Signature = StrTable.data() + Sym->st_name;
James Hendersone50d9cb2019-01-17 15:34:12 +00002636 Ret.push_back({Name,
2637 maybeDemangle(Signature),
2638 Sec.sh_name,
Alexander Shaposhnikov8febe3d2018-03-12 22:40:09 +00002639 I - 1,
2640 Sec.sh_link,
2641 Sec.sh_info,
James Hendersone50d9cb2019-01-17 15:34:12 +00002642 Data[0],
Alexander Shaposhnikov8febe3d2018-03-12 22:40:09 +00002643 {}});
George Rimarea39eed2017-09-14 07:32:52 +00002644
2645 std::vector<GroupMember> &GM = Ret.back().Members;
2646 for (uint32_t Ndx : Data.slice(1)) {
2647 auto Sec = unwrapOrError(Obj->getSection(Ndx));
2648 const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
2649 GM.push_back({Name, Ndx});
George Rimar3c0f3962017-09-14 07:26:14 +00002650 }
George Rimarc2657cd2017-09-14 07:17:04 +00002651 }
George Rimarea39eed2017-09-14 07:32:52 +00002652 return Ret;
2653}
George Rimar762abff62017-09-16 14:29:51 +00002654
2655DenseMap<uint64_t, const GroupSection *>
2656mapSectionsToGroups(ArrayRef<GroupSection> Groups) {
2657 DenseMap<uint64_t, const GroupSection *> Ret;
2658 for (const GroupSection &G : Groups)
2659 for (const GroupMember &GM : G.Members)
2660 Ret.insert({GM.Index, &G});
2661 return Ret;
2662}
2663
George Rimarea39eed2017-09-14 07:32:52 +00002664} // namespace
2665
2666template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) {
2667 std::vector<GroupSection> V = getGroups<ELFT>(Obj);
George Rimar762abff62017-09-16 14:29:51 +00002668 DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V);
George Rimarea39eed2017-09-14 07:32:52 +00002669 for (const GroupSection &G : V) {
2670 OS << "\n"
2671 << getGroupType(G.Type) << " group section ["
2672 << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature
2673 << "] contains " << G.Members.size() << " sections:\n"
2674 << " [Index] Name\n";
George Rimar762abff62017-09-16 14:29:51 +00002675 for (const GroupMember &GM : G.Members) {
2676 const GroupSection *MainGroup = Map[GM.Index];
2677 if (MainGroup != &G) {
2678 OS.flush();
2679 errs() << "Error: section [" << format_decimal(GM.Index, 5)
2680 << "] in group section [" << format_decimal(G.Index, 5)
2681 << "] already in group section ["
2682 << format_decimal(MainGroup->Index, 5) << "]";
2683 errs().flush();
2684 continue;
2685 }
George Rimarea39eed2017-09-14 07:32:52 +00002686 OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n";
George Rimar762abff62017-09-16 14:29:51 +00002687 }
George Rimarea39eed2017-09-14 07:32:52 +00002688 }
2689
2690 if (V.empty())
Hemant Kulkarni206ba842016-03-09 19:16:13 +00002691 OS << "There are no section groups in this file.\n";
2692}
2693
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00002694template <class ELFT>
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002695void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
2696 const Elf_Rela &R, bool IsRela) {
Eugene Zelenko416e0592017-06-09 21:41:54 +00002697 std::string Offset, Info, Addend, Value;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002698 SmallString<32> RelocName;
James Hendersone50d9cb2019-01-17 15:34:12 +00002699 std::string TargetName;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002700 const Elf_Sym *Sym = nullptr;
Hemant Kulkarni2e3254e2016-03-29 14:20:20 +00002701 unsigned Width = ELFT::Is64Bits ? 16 : 8;
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00002702 unsigned Bias = ELFT::Is64Bits ? 8 : 0;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002703
2704 // First two fields are bit width dependent. The rest of them are after are
2705 // fixed width.
2706 Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
2707 Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
Rafael Espindolaed1395a2016-11-03 18:05:33 +00002708 Sym = unwrapOrError(Obj->getRelocationSymbol(&R, SymTab));
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002709 if (Sym && Sym->getType() == ELF::STT_SECTION) {
2710 const Elf_Shdr *Sec = unwrapOrError(
2711 Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
2712 TargetName = unwrapOrError(Obj->getSectionName(Sec));
2713 } else if (Sym) {
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002714 StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
James Hendersone50d9cb2019-01-17 15:34:12 +00002715 TargetName = maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002716 }
2717
2718 if (Sym && IsRela) {
2719 if (R.r_addend < 0)
2720 Addend = " - ";
2721 else
2722 Addend = " + ";
2723 }
2724
2725 Offset = to_string(format_hex_no_prefix(R.r_offset, Width));
2726 Info = to_string(format_hex_no_prefix(R.r_info, Width));
2727
2728 int64_t RelAddend = R.r_addend;
2729 if (IsRela)
2730 Addend += to_hexString(std::abs(RelAddend), false);
2731
2732 if (Sym)
2733 Value = to_string(format_hex_no_prefix(Sym->getValue(), Width));
2734
2735 Fields[0].Str = Offset;
2736 Fields[1].Str = Info;
2737 Fields[2].Str = RelocName;
2738 Fields[3].Str = Value;
2739 Fields[4].Str = TargetName;
2740 for (auto &field : Fields)
2741 printField(field);
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00002742 OS << Addend;
2743 OS << "\n";
2744}
2745
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002746template <class ELFT> void GNUStyle<ELFT>::printRelocHeader(unsigned SType) {
2747 bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA;
2748 bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR;
2749 if (ELFT::Is64Bits)
2750 OS << " ";
2751 else
2752 OS << " ";
2753 if (IsRelr && opts::RawRelr)
2754 OS << "Data ";
2755 else
2756 OS << "Offset";
2757 if (ELFT::Is64Bits)
2758 OS << " Info Type"
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00002759 << " Symbol's Value Symbol's Name";
2760 else
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002761 OS << " Info Type Sym. Value Symbol's Name";
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002762 if (IsRela)
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002763 OS << " + Addend";
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002764 OS << "\n";
2765}
2766
2767template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) {
2768 bool HasRelocSections = false;
Rafael Espindola25be8c82016-11-02 14:10:57 +00002769 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002770 if (Sec.sh_type != ELF::SHT_REL &&
2771 Sec.sh_type != ELF::SHT_RELA &&
2772 Sec.sh_type != ELF::SHT_RELR &&
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002773 Sec.sh_type != ELF::SHT_ANDROID_REL &&
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002774 Sec.sh_type != ELF::SHT_ANDROID_RELA &&
2775 Sec.sh_type != ELF::SHT_ANDROID_RELR)
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002776 continue;
2777 HasRelocSections = true;
2778 StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2779 unsigned Entries = Sec.getEntityCount();
Peter Collingbournecf017ad2018-06-07 00:02:07 +00002780 std::vector<Elf_Rela> AndroidRelas;
2781 if (Sec.sh_type == ELF::SHT_ANDROID_REL ||
2782 Sec.sh_type == ELF::SHT_ANDROID_RELA) {
2783 // Android's packed relocation section needs to be unpacked first
2784 // to get the actual number of entries.
2785 AndroidRelas = unwrapOrError(Obj->android_relas(&Sec));
2786 Entries = AndroidRelas.size();
2787 }
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002788 std::vector<Elf_Rela> RelrRelas;
2789 if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR ||
2790 Sec.sh_type == ELF::SHT_ANDROID_RELR)) {
2791 // .relr.dyn relative relocation section needs to be unpacked first
2792 // to get the actual number of entries.
2793 Elf_Relr_Range Relrs = unwrapOrError(Obj->relrs(&Sec));
2794 RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
2795 Entries = RelrRelas.size();
2796 }
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002797 uintX_t Offset = Sec.sh_offset;
2798 OS << "\nRelocation section '" << Name << "' at offset 0x"
2799 << to_hexString(Offset, false) << " contains " << Entries
2800 << " entries:\n";
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002801 printRelocHeader(Sec.sh_type);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002802 const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec.sh_link));
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002803 switch (Sec.sh_type) {
2804 case ELF::SHT_REL:
Rafael Espindola354680a2016-11-03 19:07:15 +00002805 for (const auto &R : unwrapOrError(Obj->rels(&Sec))) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002806 Elf_Rela Rela;
2807 Rela.r_offset = R.r_offset;
2808 Rela.r_info = R.r_info;
2809 Rela.r_addend = 0;
2810 printRelocation(Obj, SymTab, Rela, false);
2811 }
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002812 break;
2813 case ELF::SHT_RELA:
Rafael Espindola354680a2016-11-03 19:07:15 +00002814 for (const auto &R : unwrapOrError(Obj->relas(&Sec)))
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002815 printRelocation(Obj, SymTab, R, true);
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002816 break;
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002817 case ELF::SHT_RELR:
2818 case ELF::SHT_ANDROID_RELR:
2819 if (opts::RawRelr)
2820 for (const auto &R : unwrapOrError(Obj->relrs(&Sec)))
2821 OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8))
2822 << "\n";
2823 else
2824 for (const auto &R : RelrRelas)
2825 printRelocation(Obj, SymTab, R, false);
2826 break;
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002827 case ELF::SHT_ANDROID_REL:
2828 case ELF::SHT_ANDROID_RELA:
Peter Collingbournecf017ad2018-06-07 00:02:07 +00002829 for (const auto &R : AndroidRelas)
Peter Collingbourne689e6c052017-10-25 03:37:12 +00002830 printRelocation(Obj, SymTab, R, Sec.sh_type == ELF::SHT_ANDROID_RELA);
2831 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002832 }
2833 }
2834 if (!HasRelocSections)
2835 OS << "\nThere are no relocations in this file.\n";
2836}
2837
2838std::string getSectionTypeString(unsigned Arch, unsigned Type) {
2839 using namespace ELF;
Eugene Zelenko416e0592017-06-09 21:41:54 +00002840
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002841 switch (Arch) {
2842 case EM_ARM:
2843 switch (Type) {
2844 case SHT_ARM_EXIDX:
2845 return "ARM_EXIDX";
2846 case SHT_ARM_PREEMPTMAP:
2847 return "ARM_PREEMPTMAP";
2848 case SHT_ARM_ATTRIBUTES:
2849 return "ARM_ATTRIBUTES";
2850 case SHT_ARM_DEBUGOVERLAY:
2851 return "ARM_DEBUGOVERLAY";
2852 case SHT_ARM_OVERLAYSECTION:
2853 return "ARM_OVERLAYSECTION";
2854 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00002855 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002856 case EM_X86_64:
2857 switch (Type) {
2858 case SHT_X86_64_UNWIND:
2859 return "X86_64_UNWIND";
2860 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00002861 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002862 case EM_MIPS:
2863 case EM_MIPS_RS3_LE:
2864 switch (Type) {
2865 case SHT_MIPS_REGINFO:
2866 return "MIPS_REGINFO";
2867 case SHT_MIPS_OPTIONS:
2868 return "MIPS_OPTIONS";
2869 case SHT_MIPS_ABIFLAGS:
2870 return "MIPS_ABIFLAGS";
Simon Atanasyan6cfb1012017-03-10 08:22:25 +00002871 case SHT_MIPS_DWARF:
2872 return "SHT_MIPS_DWARF";
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002873 }
Ryan Prichard0c20b5b2018-10-26 23:01:54 +00002874 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002875 }
2876 switch (Type) {
2877 case SHT_NULL:
2878 return "NULL";
2879 case SHT_PROGBITS:
2880 return "PROGBITS";
2881 case SHT_SYMTAB:
2882 return "SYMTAB";
2883 case SHT_STRTAB:
2884 return "STRTAB";
2885 case SHT_RELA:
2886 return "RELA";
2887 case SHT_HASH:
2888 return "HASH";
2889 case SHT_DYNAMIC:
2890 return "DYNAMIC";
2891 case SHT_NOTE:
2892 return "NOTE";
2893 case SHT_NOBITS:
2894 return "NOBITS";
2895 case SHT_REL:
2896 return "REL";
2897 case SHT_SHLIB:
2898 return "SHLIB";
2899 case SHT_DYNSYM:
2900 return "DYNSYM";
2901 case SHT_INIT_ARRAY:
2902 return "INIT_ARRAY";
2903 case SHT_FINI_ARRAY:
2904 return "FINI_ARRAY";
2905 case SHT_PREINIT_ARRAY:
2906 return "PREINIT_ARRAY";
2907 case SHT_GROUP:
2908 return "GROUP";
2909 case SHT_SYMTAB_SHNDX:
2910 return "SYMTAB SECTION INDICES";
Jake Ehrlich0f440d82018-06-28 21:07:34 +00002911 case SHT_RELR:
2912 case SHT_ANDROID_RELR:
2913 return "RELR";
Peter Collingbournef0e26e72017-06-14 18:52:12 +00002914 case SHT_LLVM_ODRTAB:
2915 return "LLVM_ODRTAB";
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +00002916 case SHT_LLVM_LINKER_OPTIONS:
2917 return "LLVM_LINKER_OPTIONS";
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00002918 case SHT_LLVM_CALL_GRAPH_PROFILE:
2919 return "LLVM_CALL_GRAPH_PROFILE";
Peter Collingbourne3e227332018-07-17 22:17:18 +00002920 case SHT_LLVM_ADDRSIG:
2921 return "LLVM_ADDRSIG";
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002922 // FIXME: Parse processor specific GNU attributes
2923 case SHT_GNU_ATTRIBUTES:
2924 return "ATTRIBUTES";
2925 case SHT_GNU_HASH:
2926 return "GNU_HASH";
2927 case SHT_GNU_verdef:
2928 return "VERDEF";
2929 case SHT_GNU_verneed:
2930 return "VERNEED";
2931 case SHT_GNU_versym:
2932 return "VERSYM";
2933 default:
2934 return "";
2935 }
2936 return "";
2937}
2938
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +00002939template <class ELFT>
2940void GNUStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002941 size_t SectionIndex = 0;
2942 std::string Number, Type, Size, Address, Offset, Flags, Link, Info, EntrySize,
2943 Alignment;
2944 unsigned Bias;
2945 unsigned Width;
2946
2947 if (ELFT::Is64Bits) {
2948 Bias = 0;
2949 Width = 16;
2950 } else {
2951 Bias = 8;
2952 Width = 8;
2953 }
George Rimara2b553b2018-07-19 14:52:57 +00002954
2955 ArrayRef<Elf_Shdr> Sections = unwrapOrError(Obj->sections());
2956 OS << "There are " << to_string(Sections.size())
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002957 << " section headers, starting at offset "
2958 << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n";
2959 OS << "Section Headers:\n";
2960 Field Fields[11] = {{"[Nr]", 2},
2961 {"Name", 7},
2962 {"Type", 25},
2963 {"Address", 41},
2964 {"Off", 58 - Bias},
2965 {"Size", 65 - Bias},
2966 {"ES", 72 - Bias},
2967 {"Flg", 75 - Bias},
2968 {"Lk", 79 - Bias},
2969 {"Inf", 82 - Bias},
2970 {"Al", 86 - Bias}};
2971 for (auto &f : Fields)
2972 printField(f);
2973 OS << "\n";
2974
George Rimara2b553b2018-07-19 14:52:57 +00002975 for (const Elf_Shdr &Sec : Sections) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00002976 Number = to_string(SectionIndex);
2977 Fields[0].Str = Number;
2978 Fields[1].Str = unwrapOrError(Obj->getSectionName(&Sec));
2979 Type = getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type);
2980 Fields[2].Str = Type;
2981 Address = to_string(format_hex_no_prefix(Sec.sh_addr, Width));
2982 Fields[3].Str = Address;
2983 Offset = to_string(format_hex_no_prefix(Sec.sh_offset, 6));
2984 Fields[4].Str = Offset;
2985 Size = to_string(format_hex_no_prefix(Sec.sh_size, 6));
2986 Fields[5].Str = Size;
2987 EntrySize = to_string(format_hex_no_prefix(Sec.sh_entsize, 2));
2988 Fields[6].Str = EntrySize;
2989 Flags = getGNUFlags(Sec.sh_flags);
2990 Fields[7].Str = Flags;
2991 Link = to_string(Sec.sh_link);
2992 Fields[8].Str = Link;
2993 Info = to_string(Sec.sh_info);
2994 Fields[9].Str = Info;
2995 Alignment = to_string(Sec.sh_addralign);
2996 Fields[10].Str = Alignment;
2997 OS.PadToColumn(Fields[0].Column);
2998 OS << "[" << right_justify(Fields[0].Str, 2) << "]";
2999 for (int i = 1; i < 7; i++)
3000 printField(Fields[i]);
3001 OS.PadToColumn(Fields[7].Column);
3002 OS << right_justify(Fields[7].Str, 3);
3003 OS.PadToColumn(Fields[8].Column);
3004 OS << right_justify(Fields[8].Str, 2);
3005 OS.PadToColumn(Fields[9].Column);
3006 OS << right_justify(Fields[9].Str, 3);
3007 OS.PadToColumn(Fields[10].Column);
3008 OS << right_justify(Fields[10].Str, 2);
3009 OS << "\n";
3010 ++SectionIndex;
3011 }
3012 OS << "Key to Flags:\n"
3013 << " W (write), A (alloc), X (execute), M (merge), S (strings), l "
3014 "(large)\n"
3015 << " I (info), L (link order), G (group), T (TLS), E (exclude),\
3016 x (unknown)\n"
3017 << " O (extra OS processing required) o (OS specific),\
3018 p (processor specific)\n";
3019}
3020
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00003021template <class ELFT>
3022void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name,
3023 size_t Entries) {
Eugene Zelenko416e0592017-06-09 21:41:54 +00003024 if (!Name.empty())
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00003025 OS << "\nSymbol table '" << Name << "' contains " << Entries
3026 << " entries:\n";
3027 else
3028 OS << "\n Symbol table for image:\n";
3029
3030 if (ELFT::Is64Bits)
3031 OS << " Num: Value Size Type Bind Vis Ndx Name\n";
3032 else
3033 OS << " Num: Value Size Type Bind Vis Ndx Name\n";
3034}
3035
3036template <class ELFT>
3037std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj,
3038 const Elf_Sym *Symbol,
3039 const Elf_Sym *FirstSym) {
3040 unsigned SectionIndex = Symbol->st_shndx;
3041 switch (SectionIndex) {
3042 case ELF::SHN_UNDEF:
3043 return "UND";
3044 case ELF::SHN_ABS:
3045 return "ABS";
3046 case ELF::SHN_COMMON:
3047 return "COM";
3048 case ELF::SHN_XINDEX:
Rafael Espindola714c2952016-11-03 14:41:17 +00003049 SectionIndex = unwrapOrError(object::getExtendedSymbolTableIndex<ELFT>(
Rafael Espindola7b2750a2016-11-03 13:58:15 +00003050 Symbol, FirstSym, this->dumper()->getShndxTable()));
Galina Kistanova9ee35cf2017-05-31 01:33:39 +00003051 LLVM_FALLTHROUGH;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00003052 default:
3053 // Find if:
3054 // Processor specific
3055 if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC)
3056 return std::string("PRC[0x") +
3057 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
3058 // OS specific
3059 if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS)
3060 return std::string("OS[0x") +
3061 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
3062 // Architecture reserved:
3063 if (SectionIndex >= ELF::SHN_LORESERVE &&
3064 SectionIndex <= ELF::SHN_HIRESERVE)
3065 return std::string("RSV[0x") +
3066 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
3067 // A normal section with an index
3068 return to_string(format_decimal(SectionIndex, 3));
3069 }
3070}
3071
3072template <class ELFT>
3073void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
3074 const Elf_Sym *FirstSym, StringRef StrTable,
3075 bool IsDynamic) {
3076 static int Idx = 0;
3077 static bool Dynamic = true;
3078 size_t Width;
3079
3080 // If this function was called with a different value from IsDynamic
3081 // from last call, happens when we move from dynamic to static symbol
3082 // table, "Num" field should be reset.
3083 if (!Dynamic != !IsDynamic) {
3084 Idx = 0;
3085 Dynamic = false;
3086 }
3087 std::string Num, Name, Value, Size, Binding, Type, Visibility, Section;
3088 unsigned Bias = 0;
3089 if (ELFT::Is64Bits) {
3090 Bias = 8;
3091 Width = 16;
3092 } else {
3093 Bias = 0;
3094 Width = 8;
3095 }
3096 Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias,
3097 31 + Bias, 38 + Bias, 47 + Bias, 51 + Bias};
3098 Num = to_string(format_decimal(Idx++, 6)) + ":";
3099 Value = to_string(format_hex_no_prefix(Symbol->st_value, Width));
3100 Size = to_string(format_decimal(Symbol->st_size, 5));
3101 unsigned char SymbolType = Symbol->getType();
3102 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
3103 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
3104 Type = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
3105 else
3106 Type = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
3107 unsigned Vis = Symbol->getVisibility();
3108 Binding = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
3109 Visibility = printEnum(Vis, makeArrayRef(ElfSymbolVisibilities));
3110 Section = getSymbolSectionNdx(Obj, Symbol, FirstSym);
3111 Name = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
3112 Fields[0].Str = Num;
3113 Fields[1].Str = Value;
3114 Fields[2].Str = Size;
3115 Fields[3].Str = Type;
3116 Fields[4].Str = Binding;
3117 Fields[5].Str = Visibility;
3118 Fields[6].Str = Section;
3119 Fields[7].Str = Name;
3120 for (auto &Entry : Fields)
3121 printField(Entry);
3122 OS << "\n";
3123}
Hemant Kulkarnia6ee9fd2016-11-23 18:04:23 +00003124template <class ELFT>
3125void GNUStyle<ELFT>::printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym,
3126 uint32_t Sym, StringRef StrTable,
3127 uint32_t Bucket) {
3128 std::string Num, Buc, Name, Value, Size, Binding, Type, Visibility, Section;
3129 unsigned Width, Bias = 0;
3130 if (ELFT::Is64Bits) {
3131 Bias = 8;
3132 Width = 16;
3133 } else {
3134 Bias = 0;
3135 Width = 8;
3136 }
3137 Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias,
3138 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias};
3139 Num = to_string(format_decimal(Sym, 5));
3140 Buc = to_string(format_decimal(Bucket, 3)) + ":";
3141
3142 const auto Symbol = FirstSym + Sym;
3143 Value = to_string(format_hex_no_prefix(Symbol->st_value, Width));
3144 Size = to_string(format_decimal(Symbol->st_size, 5));
3145 unsigned char SymbolType = Symbol->getType();
3146 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
3147 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
3148 Type = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
3149 else
3150 Type = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
3151 unsigned Vis = Symbol->getVisibility();
3152 Binding = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
3153 Visibility = printEnum(Vis, makeArrayRef(ElfSymbolVisibilities));
3154 Section = getSymbolSectionNdx(Obj, Symbol, FirstSym);
3155 Name = this->dumper()->getFullSymbolName(Symbol, StrTable, true);
3156 Fields[0].Str = Num;
3157 Fields[1].Str = Buc;
3158 Fields[2].Str = Value;
3159 Fields[3].Str = Size;
3160 Fields[4].Str = Type;
3161 Fields[5].Str = Binding;
3162 Fields[6].Str = Visibility;
3163 Fields[7].Str = Section;
3164 Fields[8].Str = Name;
3165 for (auto &Entry : Fields)
3166 printField(Entry);
3167 OS << "\n";
3168}
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00003169
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003170template <class ELFT> void GNUStyle<ELFT>::printSymbols(const ELFO *Obj) {
Hemant Kulkarnia6ee9fd2016-11-23 18:04:23 +00003171 if (opts::DynamicSymbols)
3172 return;
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00003173 this->dumper()->printSymbolsHelper(true);
3174 this->dumper()->printSymbolsHelper(false);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003175}
3176
3177template <class ELFT>
3178void GNUStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
Eugene Zelenko416e0592017-06-09 21:41:54 +00003179 if (this->dumper()->getDynamicStringTable().empty())
Hemant Kulkarnia6ee9fd2016-11-23 18:04:23 +00003180 return;
3181 auto StringTable = this->dumper()->getDynamicStringTable();
3182 auto DynSyms = this->dumper()->dynamic_symbols();
3183 auto GnuHash = this->dumper()->getGnuHashTable();
3184 auto SysVHash = this->dumper()->getHashTable();
3185
3186 // If no hash or .gnu.hash found, try using symbol table
3187 if (GnuHash == nullptr && SysVHash == nullptr)
3188 this->dumper()->printSymbolsHelper(true);
3189
3190 // Try printing .hash
3191 if (this->dumper()->getHashTable()) {
3192 OS << "\n Symbol table of .hash for image:\n";
3193 if (ELFT::Is64Bits)
3194 OS << " Num Buc: Value Size Type Bind Vis Ndx Name";
3195 else
3196 OS << " Num Buc: Value Size Type Bind Vis Ndx Name";
3197 OS << "\n";
3198
3199 uint32_t NBuckets = SysVHash->nbucket;
3200 uint32_t NChains = SysVHash->nchain;
3201 auto Buckets = SysVHash->buckets();
3202 auto Chains = SysVHash->chains();
3203 for (uint32_t Buc = 0; Buc < NBuckets; Buc++) {
3204 if (Buckets[Buc] == ELF::STN_UNDEF)
3205 continue;
3206 for (uint32_t Ch = Buckets[Buc]; Ch < NChains; Ch = Chains[Ch]) {
3207 if (Ch == ELF::STN_UNDEF)
3208 break;
3209 printHashedSymbol(Obj, &DynSyms[0], Ch, StringTable, Buc);
3210 }
3211 }
3212 }
3213
3214 // Try printing .gnu.hash
3215 if (GnuHash) {
3216 OS << "\n Symbol table of .gnu.hash for image:\n";
3217 if (ELFT::Is64Bits)
3218 OS << " Num Buc: Value Size Type Bind Vis Ndx Name";
3219 else
3220 OS << " Num Buc: Value Size Type Bind Vis Ndx Name";
3221 OS << "\n";
3222 uint32_t NBuckets = GnuHash->nbuckets;
3223 auto Buckets = GnuHash->buckets();
3224 for (uint32_t Buc = 0; Buc < NBuckets; Buc++) {
3225 if (Buckets[Buc] == ELF::STN_UNDEF)
3226 continue;
3227 uint32_t Index = Buckets[Buc];
3228 uint32_t GnuHashable = Index - GnuHash->symndx;
3229 // Print whole chain
3230 while (true) {
3231 printHashedSymbol(Obj, &DynSyms[0], Index++, StringTable, Buc);
3232 // Chain ends at symbol with stopper bit
3233 if ((GnuHash->values(DynSyms.size())[GnuHashable++] & 1) == 1)
3234 break;
3235 }
3236 }
3237 }
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003238}
3239
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003240static inline std::string printPhdrFlags(unsigned Flag) {
3241 std::string Str;
3242 Str = (Flag & PF_R) ? "R" : " ";
3243 Str += (Flag & PF_W) ? "W" : " ";
3244 Str += (Flag & PF_X) ? "E" : " ";
3245 return Str;
3246}
3247
3248// SHF_TLS sections are only in PT_TLS, PT_LOAD or PT_GNU_RELRO
3249// PT_TLS must only have SHF_TLS sections
3250template <class ELFT>
3251bool GNUStyle<ELFT>::checkTLSSections(const Elf_Phdr &Phdr,
3252 const Elf_Shdr &Sec) {
3253 return (((Sec.sh_flags & ELF::SHF_TLS) &&
3254 ((Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) ||
3255 (Phdr.p_type == ELF::PT_GNU_RELRO))) ||
3256 (!(Sec.sh_flags & ELF::SHF_TLS) && Phdr.p_type != ELF::PT_TLS));
3257}
3258
3259// Non-SHT_NOBITS must have its offset inside the segment
3260// Only non-zero section can be at end of segment
3261template <class ELFT>
3262bool GNUStyle<ELFT>::checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
3263 if (Sec.sh_type == ELF::SHT_NOBITS)
3264 return true;
3265 bool IsSpecial =
3266 (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0);
3267 // .tbss is special, it only has memory in PT_TLS and has NOBITS properties
3268 auto SectionSize =
3269 (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size;
3270 if (Sec.sh_offset >= Phdr.p_offset)
3271 return ((Sec.sh_offset + SectionSize <= Phdr.p_filesz + Phdr.p_offset)
3272 /*only non-zero sized sections at end*/ &&
3273 (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz));
3274 return false;
3275}
3276
3277// SHF_ALLOC must have VMA inside segment
3278// Only non-zero section can be at end of segment
3279template <class ELFT>
3280bool GNUStyle<ELFT>::checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
3281 if (!(Sec.sh_flags & ELF::SHF_ALLOC))
3282 return true;
3283 bool IsSpecial =
3284 (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0);
3285 // .tbss is special, it only has memory in PT_TLS and has NOBITS properties
3286 auto SectionSize =
3287 (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size;
3288 if (Sec.sh_addr >= Phdr.p_vaddr)
3289 return ((Sec.sh_addr + SectionSize <= Phdr.p_vaddr + Phdr.p_memsz) &&
3290 (Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz));
3291 return false;
3292}
3293
3294// No section with zero size must be at start or end of PT_DYNAMIC
3295template <class ELFT>
3296bool GNUStyle<ELFT>::checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
3297 if (Phdr.p_type != ELF::PT_DYNAMIC || Sec.sh_size != 0 || Phdr.p_memsz == 0)
3298 return true;
3299 // Is section within the phdr both based on offset and VMA ?
3300 return ((Sec.sh_type == ELF::SHT_NOBITS) ||
3301 (Sec.sh_offset > Phdr.p_offset &&
3302 Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz)) &&
3303 (!(Sec.sh_flags & ELF::SHF_ALLOC) ||
3304 (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz));
3305}
3306
3307template <class ELFT>
3308void GNUStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
Hemant Kulkarni2e3254e2016-03-29 14:20:20 +00003309 unsigned Bias = ELFT::Is64Bits ? 8 : 0;
3310 unsigned Width = ELFT::Is64Bits ? 18 : 10;
3311 unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7;
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003312 std::string Type, Offset, VMA, LMA, FileSz, MemSz, Flag, Align;
3313
3314 const Elf_Ehdr *Header = Obj->getHeader();
3315 Field Fields[8] = {2, 17, 26, 37 + Bias,
3316 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias};
3317 OS << "\nElf file type is "
3318 << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n"
Hemant Kulkarni787c2ed2016-05-12 22:51:26 +00003319 << "Entry point " << format_hex(Header->e_entry, 3) << "\n"
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003320 << "There are " << Header->e_phnum << " program headers,"
3321 << " starting at offset " << Header->e_phoff << "\n\n"
3322 << "Program Headers:\n";
3323 if (ELFT::Is64Bits)
3324 OS << " Type Offset VirtAddr PhysAddr "
3325 << " FileSiz MemSiz Flg Align\n";
3326 else
3327 OS << " Type Offset VirtAddr PhysAddr FileSiz "
3328 << "MemSiz Flg Align\n";
Rafael Espindola6a494972016-11-03 17:28:33 +00003329 for (const auto &Phdr : unwrapOrError(Obj->program_headers())) {
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003330 Type = getElfPtType(Header->e_machine, Phdr.p_type);
3331 Offset = to_string(format_hex(Phdr.p_offset, 8));
3332 VMA = to_string(format_hex(Phdr.p_vaddr, Width));
3333 LMA = to_string(format_hex(Phdr.p_paddr, Width));
3334 FileSz = to_string(format_hex(Phdr.p_filesz, SizeWidth));
3335 MemSz = to_string(format_hex(Phdr.p_memsz, SizeWidth));
3336 Flag = printPhdrFlags(Phdr.p_flags);
3337 Align = to_string(format_hex(Phdr.p_align, 1));
3338 Fields[0].Str = Type;
3339 Fields[1].Str = Offset;
3340 Fields[2].Str = VMA;
3341 Fields[3].Str = LMA;
3342 Fields[4].Str = FileSz;
3343 Fields[5].Str = MemSz;
3344 Fields[6].Str = Flag;
3345 Fields[7].Str = Align;
3346 for (auto Field : Fields)
3347 printField(Field);
3348 if (Phdr.p_type == ELF::PT_INTERP) {
3349 OS << "\n [Requesting program interpreter: ";
3350 OS << reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset << "]";
3351 }
3352 OS << "\n";
3353 }
3354 OS << "\n Section to Segment mapping:\n Segment Sections...\n";
3355 int Phnum = 0;
Rafael Espindola6a494972016-11-03 17:28:33 +00003356 for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003357 std::string Sections;
3358 OS << format(" %2.2d ", Phnum++);
Rafael Espindola25be8c82016-11-02 14:10:57 +00003359 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00003360 // Check if each section is in a segment and then print mapping.
3361 // readelf additionally makes sure it does not print zero sized sections
3362 // at end of segments and for PT_DYNAMIC both start and end of section
3363 // .tbss must only be shown in PT_TLS section.
3364 bool TbssInNonTLS = (Sec.sh_type == ELF::SHT_NOBITS) &&
3365 ((Sec.sh_flags & ELF::SHF_TLS) != 0) &&
3366 Phdr.p_type != ELF::PT_TLS;
3367 if (!TbssInNonTLS && checkTLSSections(Phdr, Sec) &&
3368 checkoffsets(Phdr, Sec) && checkVMA(Phdr, Sec) &&
3369 checkPTDynamic(Phdr, Sec) && (Sec.sh_type != ELF::SHT_NULL))
3370 Sections += unwrapOrError(Obj->getSectionName(&Sec)).str() + " ";
3371 }
3372 OS << Sections << "\n";
3373 OS.flush();
3374 }
3375}
3376
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003377template <class ELFT>
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003378void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R,
3379 bool IsRela) {
3380 SmallString<32> RelocName;
James Hendersone50d9cb2019-01-17 15:34:12 +00003381 std::string SymbolName;
Hemant Kulkarni2e3254e2016-03-29 14:20:20 +00003382 unsigned Width = ELFT::Is64Bits ? 16 : 8;
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003383 unsigned Bias = ELFT::Is64Bits ? 8 : 0;
3384 // First two fields are bit width dependent. The rest of them are after are
3385 // fixed width.
3386 Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
3387
3388 uint32_t SymIndex = R.getSymbol(Obj->isMips64EL());
3389 const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
3390 Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
James Hendersone50d9cb2019-01-17 15:34:12 +00003391 SymbolName = maybeDemangle(
3392 unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())));
Eugene Zelenko416e0592017-06-09 21:41:54 +00003393 std::string Addend, Info, Offset, Value;
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003394 Offset = to_string(format_hex_no_prefix(R.r_offset, Width));
3395 Info = to_string(format_hex_no_prefix(R.r_info, Width));
3396 Value = to_string(format_hex_no_prefix(Sym->getValue(), Width));
3397 int64_t RelAddend = R.r_addend;
Eugene Zelenko416e0592017-06-09 21:41:54 +00003398 if (!SymbolName.empty() && IsRela) {
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003399 if (R.r_addend < 0)
3400 Addend = " - ";
3401 else
3402 Addend = " + ";
3403 }
3404
Eugene Zelenko416e0592017-06-09 21:41:54 +00003405 if (SymbolName.empty() && Sym->getValue() == 0)
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003406 Value = "";
3407
3408 if (IsRela)
3409 Addend += to_string(format_hex_no_prefix(std::abs(RelAddend), 1));
3410
3411
3412 Fields[0].Str = Offset;
3413 Fields[1].Str = Info;
3414 Fields[2].Str = RelocName.c_str();
3415 Fields[3].Str = Value;
3416 Fields[4].Str = SymbolName;
3417 for (auto &Field : Fields)
3418 printField(Field);
3419 OS << Addend;
3420 OS << "\n";
3421}
3422
3423template <class ELFT>
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003424void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003425 const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
3426 const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003427 const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003428 const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
3429 if (DynRelaRegion.Size > 0) {
3430 OS << "\n'RELA' relocation section at offset "
3431 << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) -
3432 Obj->base(),
3433 1) << " contains " << DynRelaRegion.Size << " bytes:\n";
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003434 printRelocHeader(ELF::SHT_RELA);
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003435 for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
3436 printDynamicRelocation(Obj, Rela, true);
3437 }
3438 if (DynRelRegion.Size > 0) {
3439 OS << "\n'REL' relocation section at offset "
3440 << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) -
3441 Obj->base(),
3442 1) << " contains " << DynRelRegion.Size << " bytes:\n";
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003443 printRelocHeader(ELF::SHT_REL);
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003444 for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
3445 Elf_Rela Rela;
3446 Rela.r_offset = Rel.r_offset;
3447 Rela.r_info = Rel.r_info;
3448 Rela.r_addend = 0;
3449 printDynamicRelocation(Obj, Rela, false);
3450 }
3451 }
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003452 if (DynRelrRegion.Size > 0) {
3453 OS << "\n'RELR' relocation section at offset "
3454 << format_hex(reinterpret_cast<const uint8_t *>(DynRelrRegion.Addr) -
3455 Obj->base(),
3456 1) << " contains " << DynRelrRegion.Size << " bytes:\n";
3457 printRelocHeader(ELF::SHT_REL);
3458 Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
3459 std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
3460 for (const Elf_Rela &Rela : RelrRelas) {
3461 printDynamicRelocation(Obj, Rela, false);
3462 }
3463 }
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003464 if (DynPLTRelRegion.Size) {
3465 OS << "\n'PLT' relocation section at offset "
3466 << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) -
3467 Obj->base(),
3468 1) << " contains " << DynPLTRelRegion.Size << " bytes:\n";
3469 }
3470 if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003471 printRelocHeader(ELF::SHT_RELA);
Rafael Espindolaaafcf752016-04-05 14:47:22 +00003472 for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003473 printDynamicRelocation(Obj, Rela, true);
3474 } else {
Jake Ehrlich0f440d82018-06-28 21:07:34 +00003475 printRelocHeader(ELF::SHT_REL);
Rafael Espindolaaafcf752016-04-05 14:47:22 +00003476 for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
Hemant Kulkarnia79c7982016-03-29 02:41:49 +00003477 Elf_Rela Rela;
3478 Rela.r_offset = Rel.r_offset;
3479 Rela.r_info = Rel.r_info;
3480 Rela.r_addend = 0;
3481 printDynamicRelocation(Obj, Rela, false);
3482 }
3483 }
Hemant Kulkarnic030f232016-03-15 17:25:31 +00003484}
3485
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +00003486// Hash histogram shows statistics of how efficient the hash was for the
3487// dynamic symbol table. The table shows number of hash buckets for different
3488// lengths of chains as absolute number and percentage of the total buckets.
3489// Additionally cumulative coverage of symbols for each set of buckets.
3490template <class ELFT>
3491void GNUStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
3492
3493 const Elf_Hash *HashTable = this->dumper()->getHashTable();
3494 const Elf_GnuHash *GnuHashTable = this->dumper()->getGnuHashTable();
3495
3496 // Print histogram for .hash section
3497 if (HashTable) {
3498 size_t NBucket = HashTable->nbucket;
3499 size_t NChain = HashTable->nchain;
3500 ArrayRef<Elf_Word> Buckets = HashTable->buckets();
3501 ArrayRef<Elf_Word> Chains = HashTable->chains();
3502 size_t TotalSyms = 0;
3503 // If hash table is correct, we have at least chains with 0 length
3504 size_t MaxChain = 1;
3505 size_t CumulativeNonZero = 0;
3506
3507 if (NChain == 0 || NBucket == 0)
3508 return;
3509
3510 std::vector<size_t> ChainLen(NBucket, 0);
3511 // Go over all buckets and and note chain lengths of each bucket (total
3512 // unique chain lengths).
3513 for (size_t B = 0; B < NBucket; B++) {
3514 for (size_t C = Buckets[B]; C > 0 && C < NChain; C = Chains[C])
3515 if (MaxChain <= ++ChainLen[B])
3516 MaxChain++;
3517 TotalSyms += ChainLen[B];
3518 }
3519
3520 if (!TotalSyms)
3521 return;
3522
3523 std::vector<size_t> Count(MaxChain, 0) ;
3524 // Count how long is the chain for each bucket
3525 for (size_t B = 0; B < NBucket; B++)
3526 ++Count[ChainLen[B]];
3527 // Print Number of buckets with each chain lengths and their cumulative
3528 // coverage of the symbols
3529 OS << "Histogram for bucket list length (total of " << NBucket
3530 << " buckets)\n"
3531 << " Length Number % of total Coverage\n";
3532 for (size_t I = 0; I < MaxChain; I++) {
3533 CumulativeNonZero += Count[I] * I;
3534 OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I],
3535 (Count[I] * 100.0) / NBucket,
3536 (CumulativeNonZero * 100.0) / TotalSyms);
3537 }
3538 }
3539
3540 // Print histogram for .gnu.hash section
3541 if (GnuHashTable) {
3542 size_t NBucket = GnuHashTable->nbuckets;
3543 ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets();
3544 unsigned NumSyms = this->dumper()->dynamic_symbols().size();
3545 if (!NumSyms)
3546 return;
3547 ArrayRef<Elf_Word> Chains = GnuHashTable->values(NumSyms);
3548 size_t Symndx = GnuHashTable->symndx;
3549 size_t TotalSyms = 0;
3550 size_t MaxChain = 1;
3551 size_t CumulativeNonZero = 0;
3552
Eugene Zelenko416e0592017-06-09 21:41:54 +00003553 if (Chains.empty() || NBucket == 0)
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +00003554 return;
3555
3556 std::vector<size_t> ChainLen(NBucket, 0);
3557
3558 for (size_t B = 0; B < NBucket; B++) {
3559 if (!Buckets[B])
3560 continue;
3561 size_t Len = 1;
3562 for (size_t C = Buckets[B] - Symndx;
3563 C < Chains.size() && (Chains[C] & 1) == 0; C++)
3564 if (MaxChain < ++Len)
3565 MaxChain++;
3566 ChainLen[B] = Len;
3567 TotalSyms += Len;
3568 }
3569 MaxChain++;
3570
3571 if (!TotalSyms)
3572 return;
3573
3574 std::vector<size_t> Count(MaxChain, 0) ;
3575 for (size_t B = 0; B < NBucket; B++)
3576 ++Count[ChainLen[B]];
3577 // Print Number of buckets with each chain lengths and their cumulative
3578 // coverage of the symbols
3579 OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket
3580 << " buckets)\n"
3581 << " Length Number % of total Coverage\n";
3582 for (size_t I = 0; I <MaxChain; I++) {
3583 CumulativeNonZero += Count[I] * I;
3584 OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I],
3585 (Count[I] * 100.0) / NBucket,
3586 (CumulativeNonZero * 100.0) / TotalSyms);
3587 }
3588 }
3589}
3590
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00003591template <class ELFT>
3592void GNUStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) {
3593 OS << "GNUStyle::printCGProfile not implemented\n";
3594}
3595
Peter Collingbourne3e227332018-07-17 22:17:18 +00003596template <class ELFT>
3597void GNUStyle<ELFT>::printAddrsig(const ELFFile<ELFT> *Obj) {
3598 OS << "GNUStyle::printAddrsig not implemented\n";
3599}
3600
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003601static std::string getGNUNoteTypeName(const uint32_t NT) {
3602 static const struct {
3603 uint32_t ID;
3604 const char *Name;
3605 } Notes[] = {
3606 {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"},
3607 {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"},
3608 {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"},
3609 {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"},
George Rimar6a14c022018-03-21 08:34:55 +00003610 {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"},
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003611 };
3612
3613 for (const auto &Note : Notes)
3614 if (Note.ID == NT)
3615 return std::string(Note.Name);
3616
3617 std::string string;
3618 raw_string_ostream OS(string);
3619 OS << format("Unknown note type (0x%08x)", NT);
Konstantin Zhuravlyov716af742017-10-14 16:43:46 +00003620 return OS.str();
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003621}
3622
Saleem Abdulrasool4b089132017-02-12 18:55:33 +00003623static std::string getFreeBSDNoteTypeName(const uint32_t NT) {
3624 static const struct {
3625 uint32_t ID;
3626 const char *Name;
3627 } Notes[] = {
3628 {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"},
3629 {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"},
3630 {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"},
3631 {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"},
3632 {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"},
3633 {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"},
3634 {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"},
3635 {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"},
3636 {ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS,
3637 "NT_PROCSTAT_PSSTRINGS (ps_strings data)"},
3638 {ELF::NT_FREEBSD_PROCSTAT_AUXV, "NT_PROCSTAT_AUXV (auxv data)"},
3639 };
3640
3641 for (const auto &Note : Notes)
3642 if (Note.ID == NT)
3643 return std::string(Note.Name);
3644
3645 std::string string;
3646 raw_string_ostream OS(string);
3647 OS << format("Unknown note type (0x%08x)", NT);
Konstantin Zhuravlyov716af742017-10-14 16:43:46 +00003648 return OS.str();
3649}
3650
Scott Linderf5b36e52018-12-12 19:39:27 +00003651static std::string getAMDNoteTypeName(const uint32_t NT) {
Konstantin Zhuravlyov716af742017-10-14 16:43:46 +00003652 static const struct {
3653 uint32_t ID;
3654 const char *Name;
3655 } Notes[] = {
3656 {ELF::NT_AMD_AMDGPU_HSA_METADATA,
3657 "NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)"},
3658 {ELF::NT_AMD_AMDGPU_ISA,
3659 "NT_AMD_AMDGPU_ISA (ISA Version)"},
3660 {ELF::NT_AMD_AMDGPU_PAL_METADATA,
3661 "NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)"}
3662 };
3663
3664 for (const auto &Note : Notes)
3665 if (Note.ID == NT)
3666 return std::string(Note.Name);
3667
3668 std::string string;
3669 raw_string_ostream OS(string);
3670 OS << format("Unknown note type (0x%08x)", NT);
3671 return OS.str();
Saleem Abdulrasool4b089132017-02-12 18:55:33 +00003672}
3673
Scott Linderf5b36e52018-12-12 19:39:27 +00003674static std::string getAMDGPUNoteTypeName(const uint32_t NT) {
3675 if (NT == ELF::NT_AMDGPU_METADATA)
3676 return std::string("NT_AMDGPU_METADATA (AMDGPU Metadata)");
3677
3678 std::string string;
3679 raw_string_ostream OS(string);
3680 OS << format("Unknown note type (0x%08x)", NT);
3681 return OS.str();
3682}
3683
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003684template <typename ELFT>
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003685static std::string getGNUProperty(uint32_t Type, uint32_t DataSize,
3686 ArrayRef<uint8_t> Data) {
3687 std::string str;
3688 raw_string_ostream OS(str);
George Rimar6a14c022018-03-21 08:34:55 +00003689 switch (Type) {
3690 default:
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003691 OS << format("<application-specific type 0x%x>", Type);
3692 return OS.str();
George Rimar6a14c022018-03-21 08:34:55 +00003693 case GNU_PROPERTY_STACK_SIZE: {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003694 OS << "stack size: ";
George Rimar6a14c022018-03-21 08:34:55 +00003695 if (DataSize == sizeof(typename ELFT::uint))
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003696 OS << formatv("{0:x}",
3697 (uint64_t)(*(const typename ELFT::Addr *)Data.data()));
George Rimar6a14c022018-03-21 08:34:55 +00003698 else
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003699 OS << format("<corrupt length: 0x%x>", DataSize);
3700 return OS.str();
George Rimar6a14c022018-03-21 08:34:55 +00003701 }
3702 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003703 OS << "no copy on protected";
George Rimar6a14c022018-03-21 08:34:55 +00003704 if (DataSize)
3705 OS << format(" <corrupt length: 0x%x>", DataSize);
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003706 return OS.str();
Alexander Ivchenkoab60a282018-06-04 15:14:18 +00003707 case GNU_PROPERTY_X86_FEATURE_1_AND:
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003708 OS << "X86 features: ";
Alexander Ivchenkoab60a282018-06-04 15:14:18 +00003709 if (DataSize != 4 && DataSize != 8) {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003710 OS << format("<corrupt length: 0x%x>", DataSize);
3711 return OS.str();
Alexander Ivchenkoab60a282018-06-04 15:14:18 +00003712 }
3713 uint64_t CFProtection =
3714 (DataSize == 4)
3715 ? support::endian::read32<ELFT::TargetEndianness>(Data.data())
3716 : support::endian::read64<ELFT::TargetEndianness>(Data.data());
3717 if (CFProtection == 0) {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003718 OS << "none";
3719 return OS.str();
Alexander Ivchenkoab60a282018-06-04 15:14:18 +00003720 }
3721 if (CFProtection & GNU_PROPERTY_X86_FEATURE_1_IBT) {
3722 OS << "IBT";
3723 CFProtection &= ~GNU_PROPERTY_X86_FEATURE_1_IBT;
3724 if (CFProtection)
3725 OS << ", ";
3726 }
3727 if (CFProtection & GNU_PROPERTY_X86_FEATURE_1_SHSTK) {
3728 OS << "SHSTK";
3729 CFProtection &= ~GNU_PROPERTY_X86_FEATURE_1_SHSTK;
3730 if (CFProtection)
3731 OS << ", ";
3732 }
3733 if (CFProtection)
3734 OS << format("<unknown flags: 0x%llx>", CFProtection);
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003735 return OS.str();
George Rimar6a14c022018-03-21 08:34:55 +00003736 }
3737}
3738
3739template <typename ELFT>
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003740static SmallVector<std::string, 4>
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003741getGNUPropertyList(ArrayRef<uint8_t> Arr) {
George Rimar6a14c022018-03-21 08:34:55 +00003742 using Elf_Word = typename ELFT::Word;
3743
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003744 SmallVector<std::string, 4> Properties;
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003745 while (Arr.size() >= 8) {
3746 uint32_t Type = *reinterpret_cast<const Elf_Word *>(Arr.data());
3747 uint32_t DataSize = *reinterpret_cast<const Elf_Word *>(Arr.data() + 4);
3748 Arr = Arr.drop_front(8);
3749
3750 // Take padding size into account if present.
3751 uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint));
3752 std::string str;
3753 raw_string_ostream OS(str);
3754 if (Arr.size() < PaddedSize) {
3755 OS << format("<corrupt type (0x%x) datasz: 0x%x>", Type, DataSize);
3756 Properties.push_back(OS.str());
3757 break;
3758 }
3759 Properties.push_back(
3760 getGNUProperty<ELFT>(Type, DataSize, Arr.take_front(PaddedSize)));
3761 Arr = Arr.drop_front(PaddedSize);
3762 }
3763
3764 if (!Arr.empty())
3765 Properties.push_back("<corrupted GNU_PROPERTY_TYPE_0>");
3766
3767 return Properties;
3768}
3769
3770struct GNUAbiTag {
3771 std::string OSName;
3772 std::string ABI;
3773 bool IsValid;
3774};
3775
3776template <typename ELFT>
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003777static GNUAbiTag getGNUAbiTag(ArrayRef<uint8_t> Desc) {
3778 typedef typename ELFT::Word Elf_Word;
3779
3780 ArrayRef<Elf_Word> Words(reinterpret_cast<const Elf_Word*>(Desc.begin()),
3781 reinterpret_cast<const Elf_Word*>(Desc.end()));
3782
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003783 if (Words.size() < 4)
3784 return {"", "", /*IsValid=*/false};
3785
3786 static const char *OSNames[] = {
3787 "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl",
3788 };
3789 StringRef OSName = "Unknown";
3790 if (Words[0] < array_lengthof(OSNames))
3791 OSName = OSNames[Words[0]];
3792 uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3];
3793 std::string str;
3794 raw_string_ostream ABI(str);
3795 ABI << Major << "." << Minor << "." << Patch;
3796 return {OSName, ABI.str(), /*IsValid=*/true};
3797}
3798
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003799static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003800 std::string str;
3801 raw_string_ostream OS(str);
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003802 for (const auto &B : Desc)
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003803 OS << format_hex_no_prefix(B, 2);
3804 return OS.str();
3805}
3806
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003807static StringRef getGNUGoldVersion(ArrayRef<uint8_t> Desc) {
3808 return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003809}
3810
3811template <typename ELFT>
3812static void printGNUNote(raw_ostream &OS, uint32_t NoteType,
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003813 ArrayRef<uint8_t> Desc) {
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003814 switch (NoteType) {
3815 default:
3816 return;
3817 case ELF::NT_GNU_ABI_TAG: {
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003818 const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc);
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003819 if (!AbiTag.IsValid)
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003820 OS << " <corrupt GNU_ABI_TAG>";
3821 else
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003822 OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI;
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003823 break;
3824 }
3825 case ELF::NT_GNU_BUILD_ID: {
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003826 OS << " Build ID: " << getGNUBuildId(Desc);
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003827 break;
3828 }
3829 case ELF::NT_GNU_GOLD_VERSION:
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003830 OS << " Version: " << getGNUGoldVersion(Desc);
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003831 break;
George Rimar6a14c022018-03-21 08:34:55 +00003832 case ELF::NT_GNU_PROPERTY_TYPE_0:
3833 OS << " Properties:";
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003834 for (const auto &Property : getGNUPropertyList<ELFT>(Desc))
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003835 OS << " " << Property << "\n";
George Rimar6a14c022018-03-21 08:34:55 +00003836 break;
3837 }
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003838 OS << '\n';
3839}
3840
Scott Linderf5b36e52018-12-12 19:39:27 +00003841struct AMDNote {
3842 std::string Type;
3843 std::string Value;
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003844};
3845
Konstantin Zhuravlyovb3c605d2017-10-14 18:21:42 +00003846template <typename ELFT>
Scott Linderf5b36e52018-12-12 19:39:27 +00003847static AMDNote getAMDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) {
Konstantin Zhuravlyovb3c605d2017-10-14 18:21:42 +00003848 switch (NoteType) {
3849 default:
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003850 return {"", ""};
3851 case ELF::NT_AMD_AMDGPU_HSA_METADATA:
3852 return {"HSA Metadata",
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003853 std::string(reinterpret_cast<const char *>(Desc.data()),
3854 Desc.size())};
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003855 case ELF::NT_AMD_AMDGPU_ISA:
3856 return {"ISA Version",
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003857 std::string(reinterpret_cast<const char *>(Desc.data()),
3858 Desc.size())};
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003859 case ELF::NT_AMD_AMDGPU_PAL_METADATA:
3860 const uint32_t *PALMetadataBegin =
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003861 reinterpret_cast<const uint32_t *>(Desc.data());
3862 const uint32_t *PALMetadataEnd = PALMetadataBegin + Desc.size();
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003863 std::vector<uint32_t> PALMetadata(PALMetadataBegin, PALMetadataEnd);
3864 std::string PALMetadataString;
3865 auto Error = AMDGPU::PALMD::toString(PALMetadata, PALMetadataString);
3866 if (Error) {
3867 return {"PAL Metadata", "Invalid"};
3868 }
3869 return {"PAL Metadata", PALMetadataString};
Konstantin Zhuravlyovb3c605d2017-10-14 18:21:42 +00003870 }
Konstantin Zhuravlyovb3c605d2017-10-14 18:21:42 +00003871}
3872
Scott Linderf5b36e52018-12-12 19:39:27 +00003873struct AMDGPUNote {
3874 std::string Type;
3875 std::string Value;
3876};
3877
3878template <typename ELFT>
3879static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) {
3880 switch (NoteType) {
3881 default:
3882 return {"", ""};
3883 case ELF::NT_AMDGPU_METADATA:
3884 auto MsgPackString =
3885 StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
3886 msgpack::Reader MsgPackReader(MsgPackString);
3887 auto OptMsgPackNodeOrErr = msgpack::Node::read(MsgPackReader);
3888 if (errorToBool(OptMsgPackNodeOrErr.takeError()))
3889 return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"};
3890 auto &OptMsgPackNode = *OptMsgPackNodeOrErr;
3891 if (!OptMsgPackNode)
3892 return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"};
3893 auto &MsgPackNode = *OptMsgPackNode;
3894
3895 AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true);
3896 if (!Verifier.verify(*MsgPackNode))
3897 return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"};
3898
3899 std::string HSAMetadataString;
3900 raw_string_ostream StrOS(HSAMetadataString);
3901 yaml::Output YOut(StrOS);
3902 YOut << MsgPackNode;
3903
3904 return {"AMDGPU Metadata", StrOS.str()};
3905 }
3906}
3907
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003908template <class ELFT>
3909void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
3910 const Elf_Ehdr *e = Obj->getHeader();
3911 bool IsCore = e->e_type == ELF::ET_CORE;
3912
Scott Linder77a5f212018-03-12 19:28:50 +00003913 auto PrintHeader = [&](const typename ELFT::Off Offset,
3914 const typename ELFT::Addr Size) {
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003915 OS << "Displaying notes found at file offset " << format_hex(Offset, 10)
3916 << " with length " << format_hex(Size, 10) << ":\n"
3917 << " Owner Data size\tDescription\n";
Scott Linder77a5f212018-03-12 19:28:50 +00003918 };
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003919
Scott Linder77a5f212018-03-12 19:28:50 +00003920 auto ProcessNote = [&](const Elf_Note &Note) {
3921 StringRef Name = Note.getName();
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00003922 ArrayRef<uint8_t> Descriptor = Note.getDesc();
Scott Linder77a5f212018-03-12 19:28:50 +00003923 Elf_Word Type = Note.getType();
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003924
Scott Linder77a5f212018-03-12 19:28:50 +00003925 OS << " " << Name << std::string(22 - Name.size(), ' ')
3926 << format_hex(Descriptor.size(), 10) << '\t';
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003927
Scott Linder77a5f212018-03-12 19:28:50 +00003928 if (Name == "GNU") {
3929 OS << getGNUNoteTypeName(Type) << '\n';
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003930 printGNUNote<ELFT>(OS, Type, Descriptor);
Scott Linder77a5f212018-03-12 19:28:50 +00003931 } else if (Name == "FreeBSD") {
3932 OS << getFreeBSDNoteTypeName(Type) << '\n';
3933 } else if (Name == "AMD") {
Scott Linderf5b36e52018-12-12 19:39:27 +00003934 OS << getAMDNoteTypeName(Type) << '\n';
3935 const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
3936 if (!N.Type.empty())
3937 OS << " " << N.Type << ":\n " << N.Value << '\n';
3938 } else if (Name == "AMDGPU") {
Scott Linder77a5f212018-03-12 19:28:50 +00003939 OS << getAMDGPUNoteTypeName(Type) << '\n';
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00003940 const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
Scott Linderf5b36e52018-12-12 19:39:27 +00003941 if (!N.Type.empty())
3942 OS << " " << N.Type << ":\n " << N.Value << '\n';
Scott Linder77a5f212018-03-12 19:28:50 +00003943 } else {
3944 OS << "Unknown note type: (" << format_hex(Type, 10) << ')';
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003945 }
Scott Linder77a5f212018-03-12 19:28:50 +00003946 OS << '\n';
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003947 };
3948
3949 if (IsCore) {
Scott Linder77a5f212018-03-12 19:28:50 +00003950 for (const auto &P : unwrapOrError(Obj->program_headers())) {
3951 if (P.p_type != PT_NOTE)
3952 continue;
3953 PrintHeader(P.p_offset, P.p_filesz);
3954 Error Err = Error::success();
3955 for (const auto &Note : Obj->notes(P, Err))
3956 ProcessNote(Note);
3957 if (Err)
3958 error(std::move(Err));
3959 }
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003960 } else {
Scott Linder77a5f212018-03-12 19:28:50 +00003961 for (const auto &S : unwrapOrError(Obj->sections())) {
3962 if (S.sh_type != SHT_NOTE)
3963 continue;
3964 PrintHeader(S.sh_offset, S.sh_size);
3965 Error Err = Error::success();
3966 for (const auto &Note : Obj->notes(S, Err))
3967 ProcessNote(Note);
3968 if (Err)
3969 error(std::move(Err));
3970 }
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00003971 }
3972}
3973
Simon Atanasyan62d32592017-12-21 10:26:02 +00003974template <class ELFT>
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +00003975void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
3976 OS << "printELFLinkerOptions not implemented!\n";
3977}
3978
3979template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00003980void GNUStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
3981 size_t Bias = ELFT::Is64Bits ? 8 : 0;
3982 auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) {
3983 OS.PadToColumn(2);
3984 OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias);
3985 OS.PadToColumn(11 + Bias);
3986 OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)";
3987 OS.PadToColumn(22 + Bias);
3988 OS << format_hex_no_prefix(*E, 8 + Bias);
3989 OS.PadToColumn(31 + 2 * Bias);
3990 OS << Purpose << "\n";
3991 };
3992
3993 OS << (Parser.IsStatic ? "Static GOT:\n" : "Primary GOT:\n");
3994 OS << " Canonical gp value: "
3995 << format_hex_no_prefix(Parser.getGp(), 8 + Bias) << "\n\n";
3996
3997 OS << " Reserved entries:\n";
3998 OS << " Address Access Initial Purpose\n";
3999 PrintEntry(Parser.getGotLazyResolver(), "Lazy resolver");
4000 if (Parser.getGotModulePointer())
4001 PrintEntry(Parser.getGotModulePointer(), "Module pointer (GNU extension)");
4002
4003 if (!Parser.getLocalEntries().empty()) {
4004 OS << "\n";
4005 OS << " Local entries:\n";
4006 OS << " Address Access Initial\n";
4007 for (auto &E : Parser.getLocalEntries())
4008 PrintEntry(&E, "");
4009 }
4010
4011 if (Parser.IsStatic)
4012 return;
4013
4014 if (!Parser.getGlobalEntries().empty()) {
4015 OS << "\n";
4016 OS << " Global entries:\n";
4017 OS << " Address Access Initial Sym.Val. Type Ndx Name\n";
4018 for (auto &E : Parser.getGlobalEntries()) {
4019 const Elf_Sym *Sym = Parser.getGotSym(&E);
4020 std::string SymName = this->dumper()->getFullSymbolName(
4021 Sym, this->dumper()->getDynamicStringTable(), false);
4022
4023 OS.PadToColumn(2);
4024 OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias));
4025 OS.PadToColumn(11 + Bias);
4026 OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)";
4027 OS.PadToColumn(22 + Bias);
4028 OS << to_string(format_hex_no_prefix(E, 8 + Bias));
4029 OS.PadToColumn(31 + 2 * Bias);
4030 OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias));
4031 OS.PadToColumn(40 + 3 * Bias);
4032 OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes));
4033 OS.PadToColumn(48 + 3 * Bias);
4034 OS << getSymbolSectionNdx(Parser.Obj, Sym,
4035 this->dumper()->dynamic_symbols().begin());
4036 OS.PadToColumn(52 + 3 * Bias);
4037 OS << SymName << "\n";
4038 }
4039 }
4040
4041 if (!Parser.getOtherEntries().empty())
4042 OS << "\n Number of TLS and multi-GOT entries "
4043 << Parser.getOtherEntries().size() << "\n";
4044}
4045
4046template <class ELFT>
4047void GNUStyle<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) {
4048 size_t Bias = ELFT::Is64Bits ? 8 : 0;
4049 auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) {
4050 OS.PadToColumn(2);
4051 OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias);
4052 OS.PadToColumn(11 + Bias);
4053 OS << format_hex_no_prefix(*E, 8 + Bias);
4054 OS.PadToColumn(20 + 2 * Bias);
4055 OS << Purpose << "\n";
4056 };
4057
4058 OS << "PLT GOT:\n\n";
4059
4060 OS << " Reserved entries:\n";
4061 OS << " Address Initial Purpose\n";
4062 PrintEntry(Parser.getPltLazyResolver(), "PLT lazy resolver");
4063 if (Parser.getPltModulePointer())
4064 PrintEntry(Parser.getGotModulePointer(), "Module pointer");
4065
4066 if (!Parser.getPltEntries().empty()) {
4067 OS << "\n";
4068 OS << " Entries:\n";
4069 OS << " Address Initial Sym.Val. Type Ndx Name\n";
4070 for (auto &E : Parser.getPltEntries()) {
4071 const Elf_Sym *Sym = Parser.getPltSym(&E);
4072 std::string SymName = this->dumper()->getFullSymbolName(
4073 Sym, this->dumper()->getDynamicStringTable(), false);
4074
4075 OS.PadToColumn(2);
4076 OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias));
4077 OS.PadToColumn(11 + Bias);
4078 OS << to_string(format_hex_no_prefix(E, 8 + Bias));
4079 OS.PadToColumn(20 + 2 * Bias);
4080 OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias));
4081 OS.PadToColumn(29 + 3 * Bias);
4082 OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes));
4083 OS.PadToColumn(37 + 3 * Bias);
4084 OS << getSymbolSectionNdx(Parser.Obj, Sym,
4085 this->dumper()->dynamic_symbols().begin());
4086 OS.PadToColumn(41 + 3 * Bias);
4087 OS << SymName << "\n";
4088 }
4089 }
4090}
4091
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004092template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00004093 const Elf_Ehdr *e = Obj->getHeader();
4094 {
4095 DictScope D(W, "ElfHeader");
4096 {
4097 DictScope D(W, "Ident");
4098 W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
4099 W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
4100 W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA],
4101 makeArrayRef(ElfDataEncoding));
4102 W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]);
4103
Konstantin Zhuravlyov121125f2017-10-02 20:49:58 +00004104 auto OSABI = makeArrayRef(ElfOSABI);
4105 if (e->e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH &&
4106 e->e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) {
4107 switch (e->e_machine) {
4108 case ELF::EM_AMDGPU:
4109 OSABI = makeArrayRef(AMDGPUElfOSABI);
4110 break;
4111 case ELF::EM_ARM:
4112 OSABI = makeArrayRef(ARMElfOSABI);
4113 break;
4114 case ELF::EM_TI_C6000:
4115 OSABI = makeArrayRef(C6000ElfOSABI);
4116 break;
4117 }
4118 }
4119 W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI], OSABI);
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00004120 W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]);
4121 W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD));
4122 }
4123
4124 W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType));
4125 W.printEnum("Machine", e->e_machine, makeArrayRef(ElfMachineType));
4126 W.printNumber("Version", e->e_version);
4127 W.printHex("Entry", e->e_entry);
4128 W.printHex("ProgramHeaderOffset", e->e_phoff);
4129 W.printHex("SectionHeaderOffset", e->e_shoff);
4130 if (e->e_machine == EM_MIPS)
4131 W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
4132 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
4133 unsigned(ELF::EF_MIPS_MACH));
Konstantin Zhuravlyovaa0835a2017-10-05 16:19:18 +00004134 else if (e->e_machine == EM_AMDGPU)
4135 W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderAMDGPUFlags),
Konstantin Zhuravlyov9122a632018-02-16 22:33:59 +00004136 unsigned(ELF::EF_AMDGPU_MACH));
Alex Bradburybb89b2b2017-10-03 08:41:59 +00004137 else if (e->e_machine == EM_RISCV)
4138 W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderRISCVFlags));
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00004139 else
4140 W.printFlags("Flags", e->e_flags);
4141 W.printNumber("HeaderSize", e->e_ehsize);
4142 W.printNumber("ProgramHeaderEntrySize", e->e_phentsize);
4143 W.printNumber("ProgramHeaderCount", e->e_phnum);
4144 W.printNumber("SectionHeaderEntrySize", e->e_shentsize);
George Rimar6fdac3b2018-07-18 08:19:58 +00004145 W.printString("SectionHeaderCount", getSectionHeadersNumString(Obj));
4146 W.printString("StringTableSectionIndex", getSectionHeaderTableIndexString(Obj));
Hemant Kulkarnid8a985e2016-02-10 20:40:55 +00004147 }
4148}
Hemant Kulkarni206ba842016-03-09 19:16:13 +00004149
4150template <class ELFT>
4151void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) {
4152 DictScope Lists(W, "Groups");
George Rimarea39eed2017-09-14 07:32:52 +00004153 std::vector<GroupSection> V = getGroups<ELFT>(Obj);
George Rimar762abff62017-09-16 14:29:51 +00004154 DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V);
George Rimarea39eed2017-09-14 07:32:52 +00004155 for (const GroupSection &G : V) {
4156 DictScope D(W, "Group");
4157 W.printNumber("Name", G.Name, G.ShName);
4158 W.printNumber("Index", G.Index);
Alexander Shaposhnikov8febe3d2018-03-12 22:40:09 +00004159 W.printNumber("Link", G.Link);
4160 W.printNumber("Info", G.Info);
George Rimarea39eed2017-09-14 07:32:52 +00004161 W.printHex("Type", getGroupType(G.Type), G.Type);
4162 W.startLine() << "Signature: " << G.Signature << "\n";
4163
4164 ListScope L(W, "Section(s) in group");
George Rimar762abff62017-09-16 14:29:51 +00004165 for (const GroupMember &GM : G.Members) {
4166 const GroupSection *MainGroup = Map[GM.Index];
4167 if (MainGroup != &G) {
4168 W.flush();
4169 errs() << "Error: " << GM.Name << " (" << GM.Index
4170 << ") in a group " + G.Name + " (" << G.Index
4171 << ") is already in a group " + MainGroup->Name + " ("
4172 << MainGroup->Index << ")\n";
4173 errs().flush();
4174 continue;
4175 }
George Rimarea39eed2017-09-14 07:32:52 +00004176 W.startLine() << GM.Name << " (" << GM.Index << ")\n";
George Rimar762abff62017-09-16 14:29:51 +00004177 }
Hemant Kulkarni206ba842016-03-09 19:16:13 +00004178 }
George Rimarea39eed2017-09-14 07:32:52 +00004179
4180 if (V.empty())
Hemant Kulkarni206ba842016-03-09 19:16:13 +00004181 W.startLine() << "There are no group sections in the file.\n";
4182}
George Rimar762abff62017-09-16 14:29:51 +00004183
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004184template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) {
4185 ListScope D(W, "Relocations");
4186
4187 int SectionNumber = -1;
Rafael Espindola25be8c82016-11-02 14:10:57 +00004188 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004189 ++SectionNumber;
4190
Jake Ehrlich0f440d82018-06-28 21:07:34 +00004191 if (Sec.sh_type != ELF::SHT_REL &&
4192 Sec.sh_type != ELF::SHT_RELA &&
4193 Sec.sh_type != ELF::SHT_RELR &&
Peter Collingbourne689e6c052017-10-25 03:37:12 +00004194 Sec.sh_type != ELF::SHT_ANDROID_REL &&
Jake Ehrlich0f440d82018-06-28 21:07:34 +00004195 Sec.sh_type != ELF::SHT_ANDROID_RELA &&
4196 Sec.sh_type != ELF::SHT_ANDROID_RELR)
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004197 continue;
4198
4199 StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
4200
4201 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
4202 W.indent();
4203
4204 printRelocations(&Sec, Obj);
4205
4206 W.unindent();
4207 W.startLine() << "}\n";
4208 }
4209}
4210
4211template <class ELFT>
4212void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) {
4213 const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec->sh_link));
4214
4215 switch (Sec->sh_type) {
4216 case ELF::SHT_REL:
Rafael Espindola354680a2016-11-03 19:07:15 +00004217 for (const Elf_Rel &R : unwrapOrError(Obj->rels(Sec))) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004218 Elf_Rela Rela;
4219 Rela.r_offset = R.r_offset;
4220 Rela.r_info = R.r_info;
4221 Rela.r_addend = 0;
4222 printRelocation(Obj, Rela, SymTab);
4223 }
4224 break;
4225 case ELF::SHT_RELA:
Rafael Espindola354680a2016-11-03 19:07:15 +00004226 for (const Elf_Rela &R : unwrapOrError(Obj->relas(Sec)))
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004227 printRelocation(Obj, R, SymTab);
4228 break;
Jake Ehrlich0f440d82018-06-28 21:07:34 +00004229 case ELF::SHT_RELR:
4230 case ELF::SHT_ANDROID_RELR: {
4231 Elf_Relr_Range Relrs = unwrapOrError(Obj->relrs(Sec));
4232 if (opts::RawRelr) {
4233 for (const Elf_Relr &R : Relrs)
4234 W.startLine() << W.hex(R) << "\n";
4235 } else {
4236 std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
4237 for (const Elf_Rela &R : RelrRelas)
4238 printRelocation(Obj, R, SymTab);
4239 }
4240 break;
4241 }
Peter Collingbourne689e6c052017-10-25 03:37:12 +00004242 case ELF::SHT_ANDROID_REL:
4243 case ELF::SHT_ANDROID_RELA:
4244 for (const Elf_Rela &R : unwrapOrError(Obj->android_relas(Sec)))
4245 printRelocation(Obj, R, SymTab);
4246 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004247 }
4248}
4249
4250template <class ELFT>
4251void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
4252 const Elf_Shdr *SymTab) {
4253 SmallString<32> RelocName;
4254 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
James Hendersone50d9cb2019-01-17 15:34:12 +00004255 std::string TargetName;
Rafael Espindolaed1395a2016-11-03 18:05:33 +00004256 const Elf_Sym *Sym = unwrapOrError(Obj->getRelocationSymbol(&Rel, SymTab));
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004257 if (Sym && Sym->getType() == ELF::STT_SECTION) {
4258 const Elf_Shdr *Sec = unwrapOrError(
4259 Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
4260 TargetName = unwrapOrError(Obj->getSectionName(Sec));
4261 } else if (Sym) {
4262 StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
James Hendersone50d9cb2019-01-17 15:34:12 +00004263 TargetName = maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004264 }
4265
4266 if (opts::ExpandRelocs) {
4267 DictScope Group(W, "Relocation");
4268 W.printHex("Offset", Rel.r_offset);
4269 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
Eugene Zelenko416e0592017-06-09 21:41:54 +00004270 W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-",
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004271 Rel.getSymbol(Obj->isMips64EL()));
4272 W.printHex("Addend", Rel.r_addend);
4273 } else {
4274 raw_ostream &OS = W.startLine();
4275 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
Eugene Zelenko416e0592017-06-09 21:41:54 +00004276 << (!TargetName.empty() ? TargetName : "-") << " "
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004277 << W.hex(Rel.r_addend) << "\n";
4278 }
4279}
4280
Jordan Rupprechtdbf552c2018-11-12 18:02:38 +00004281template <class ELFT>
4282void LLVMStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004283 ListScope SectionsD(W, "Sections");
4284
4285 int SectionIndex = -1;
Rafael Espindola25be8c82016-11-02 14:10:57 +00004286 for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004287 ++SectionIndex;
4288
4289 StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
4290
4291 DictScope SectionD(W, "Section");
4292 W.printNumber("Index", SectionIndex);
4293 W.printNumber("Name", Name, Sec.sh_name);
Rafael Espindola3ba25732017-05-02 14:04:52 +00004294 W.printHex(
4295 "Type",
4296 object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec.sh_type),
4297 Sec.sh_type);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004298 std::vector<EnumEntry<unsigned>> SectionFlags(std::begin(ElfSectionFlags),
4299 std::end(ElfSectionFlags));
4300 switch (Obj->getHeader()->e_machine) {
Prakhar Bahuguna52a7dd72016-12-15 07:59:08 +00004301 case EM_ARM:
4302 SectionFlags.insert(SectionFlags.end(), std::begin(ElfARMSectionFlags),
4303 std::end(ElfARMSectionFlags));
4304 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004305 case EM_HEXAGON:
4306 SectionFlags.insert(SectionFlags.end(),
4307 std::begin(ElfHexagonSectionFlags),
4308 std::end(ElfHexagonSectionFlags));
4309 break;
4310 case EM_MIPS:
4311 SectionFlags.insert(SectionFlags.end(), std::begin(ElfMipsSectionFlags),
4312 std::end(ElfMipsSectionFlags));
4313 break;
4314 case EM_X86_64:
4315 SectionFlags.insert(SectionFlags.end(), std::begin(ElfX86_64SectionFlags),
4316 std::end(ElfX86_64SectionFlags));
4317 break;
George Rimarc13c59a2016-05-21 10:16:58 +00004318 case EM_XCORE:
4319 SectionFlags.insert(SectionFlags.end(), std::begin(ElfXCoreSectionFlags),
4320 std::end(ElfXCoreSectionFlags));
4321 break;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004322 default:
4323 // Nothing to do.
4324 break;
4325 }
4326 W.printFlags("Flags", Sec.sh_flags, makeArrayRef(SectionFlags));
4327 W.printHex("Address", Sec.sh_addr);
4328 W.printHex("Offset", Sec.sh_offset);
4329 W.printNumber("Size", Sec.sh_size);
4330 W.printNumber("Link", Sec.sh_link);
4331 W.printNumber("Info", Sec.sh_info);
4332 W.printNumber("AddressAlignment", Sec.sh_addralign);
4333 W.printNumber("EntrySize", Sec.sh_entsize);
4334
4335 if (opts::SectionRelocations) {
4336 ListScope D(W, "Relocations");
4337 printRelocations(&Sec, Obj);
4338 }
4339
4340 if (opts::SectionSymbols) {
4341 ListScope D(W, "Symbols");
4342 const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec();
4343 StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
4344
Rafael Espindola9ea68342016-11-03 13:43:30 +00004345 for (const Elf_Sym &Sym : unwrapOrError(Obj->symbols(Symtab))) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004346 const Elf_Shdr *SymSec = unwrapOrError(
4347 Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable()));
4348 if (SymSec == &Sec)
Rafael Espindola9ea68342016-11-03 13:43:30 +00004349 printSymbol(Obj, &Sym, unwrapOrError(Obj->symbols(Symtab)).begin(),
4350 StrTable, false);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004351 }
4352 }
4353
4354 if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
4355 ArrayRef<uint8_t> Data = unwrapOrError(Obj->getSectionContents(&Sec));
4356 W.printBinaryBlock("SectionData",
4357 StringRef((const char *)Data.data(), Data.size()));
4358 }
4359 }
4360}
4361
4362template <class ELFT>
4363void LLVMStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
4364 const Elf_Sym *First, StringRef StrTable,
4365 bool IsDynamic) {
4366 unsigned SectionIndex = 0;
4367 StringRef SectionName;
Simon Atanasyan62d32592017-12-21 10:26:02 +00004368 this->dumper()->getSectionNameIndex(Symbol, First, SectionName, SectionIndex);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004369 std::string FullSymbolName =
4370 this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
4371 unsigned char SymbolType = Symbol->getType();
4372
4373 DictScope D(W, "Symbol");
4374 W.printNumber("Name", FullSymbolName, Symbol->st_name);
4375 W.printHex("Value", Symbol->st_value);
4376 W.printNumber("Size", Symbol->st_size);
4377 W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
4378 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
4379 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
4380 W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes));
4381 else
4382 W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes));
Simon Atanasyanb7807a02016-03-24 16:10:37 +00004383 if (Symbol->st_other == 0)
4384 // Usually st_other flag is zero. Do not pollute the output
4385 // by flags enumeration in that case.
4386 W.printNumber("Other", 0);
4387 else {
4388 std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags),
4389 std::end(ElfSymOtherFlags));
4390 if (Obj->getHeader()->e_machine == EM_MIPS) {
4391 // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16
4392 // flag overlapped with other ST_MIPS_xxx flags. So consider both
4393 // cases separately.
4394 if ((Symbol->st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16)
4395 SymOtherFlags.insert(SymOtherFlags.end(),
4396 std::begin(ElfMips16SymOtherFlags),
4397 std::end(ElfMips16SymOtherFlags));
4398 else
4399 SymOtherFlags.insert(SymOtherFlags.end(),
4400 std::begin(ElfMipsSymOtherFlags),
4401 std::end(ElfMipsSymOtherFlags));
4402 }
4403 W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u);
4404 }
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004405 W.printHex("Section", SectionName, SectionIndex);
4406}
4407
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004408template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) {
4409 ListScope Group(W, "Symbols");
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00004410 this->dumper()->printSymbolsHelper(false);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004411}
4412
4413template <class ELFT>
4414void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
4415 ListScope Group(W, "DynamicSymbols");
Hemant Kulkarnia11fbe12016-03-21 17:18:23 +00004416 this->dumper()->printSymbolsHelper(true);
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004417}
4418
4419template <class ELFT>
4420void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
4421 const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
4422 const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
Jake Ehrlich0f440d82018-06-28 21:07:34 +00004423 const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004424 const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
4425 if (DynRelRegion.Size && DynRelaRegion.Size)
4426 report_fatal_error("There are both REL and RELA dynamic relocations");
4427 W.startLine() << "Dynamic Relocations {\n";
4428 W.indent();
4429 if (DynRelaRegion.Size > 0)
4430 for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
4431 printDynamicRelocation(Obj, Rela);
4432 else
4433 for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
4434 Elf_Rela Rela;
4435 Rela.r_offset = Rel.r_offset;
4436 Rela.r_info = Rel.r_info;
4437 Rela.r_addend = 0;
4438 printDynamicRelocation(Obj, Rela);
4439 }
Jake Ehrlich0f440d82018-06-28 21:07:34 +00004440 if (DynRelrRegion.Size > 0) {
4441 Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
4442 std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
4443 for (const Elf_Rela &Rela : RelrRelas)
4444 printDynamicRelocation(Obj, Rela);
4445 }
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004446 if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
Rafael Espindolaaafcf752016-04-05 14:47:22 +00004447 for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004448 printDynamicRelocation(Obj, Rela);
4449 else
Rafael Espindolaaafcf752016-04-05 14:47:22 +00004450 for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004451 Elf_Rela Rela;
4452 Rela.r_offset = Rel.r_offset;
4453 Rela.r_info = Rel.r_info;
4454 Rela.r_addend = 0;
4455 printDynamicRelocation(Obj, Rela);
4456 }
4457 W.unindent();
4458 W.startLine() << "}\n";
4459}
4460
4461template <class ELFT>
4462void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel) {
4463 SmallString<32> RelocName;
4464 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
James Hendersone50d9cb2019-01-17 15:34:12 +00004465 std::string SymbolName;
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004466 uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
4467 const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
James Hendersone50d9cb2019-01-17 15:34:12 +00004468 SymbolName = maybeDemangle(
4469 unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())));
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004470 if (opts::ExpandRelocs) {
4471 DictScope Group(W, "Relocation");
4472 W.printHex("Offset", Rel.r_offset);
4473 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
Eugene Zelenko416e0592017-06-09 21:41:54 +00004474 W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-");
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004475 W.printHex("Addend", Rel.r_addend);
4476 } else {
4477 raw_ostream &OS = W.startLine();
4478 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
Eugene Zelenko416e0592017-06-09 21:41:54 +00004479 << (!SymbolName.empty() ? SymbolName : "-") << " "
Hemant Kulkarnic030f232016-03-15 17:25:31 +00004480 << W.hex(Rel.r_addend) << "\n";
4481 }
4482}
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00004483
4484template <class ELFT>
4485void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
4486 ListScope L(W, "ProgramHeaders");
4487
Rafael Espindola6a494972016-11-03 17:28:33 +00004488 for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
Hemant Kulkarni966b3ac2016-03-25 16:04:48 +00004489 DictScope P(W, "ProgramHeader");
4490 W.printHex("Type",
4491 getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
4492 Phdr.p_type);
4493 W.printHex("Offset", Phdr.p_offset);
4494 W.printHex("VirtualAddress", Phdr.p_vaddr);
4495 W.printHex("PhysicalAddress", Phdr.p_paddr);
4496 W.printNumber("FileSize", Phdr.p_filesz);
4497 W.printNumber("MemSize", Phdr.p_memsz);
4498 W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
4499 W.printNumber("Alignment", Phdr.p_align);
4500 }
4501}
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00004502
Hemant Kulkarni9b1b7f02016-04-11 17:15:30 +00004503template <class ELFT>
4504void LLVMStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
4505 W.startLine() << "Hash Histogram not implemented!\n";
4506}
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00004507
4508template <class ELFT>
Michael J. Spencerae6eeae2018-06-02 16:33:01 +00004509void LLVMStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) {
4510 ListScope L(W, "CGProfile");
4511 if (!this->dumper()->getDotCGProfileSec())
4512 return;
4513 auto CGProfile =
4514 unwrapOrError(Obj->template getSectionContentsAsArray<Elf_CGProfile>(
4515 this->dumper()->getDotCGProfileSec()));
4516 for (const Elf_CGProfile &CGPE : CGProfile) {
4517 DictScope D(W, "CGProfileEntry");
4518 W.printNumber("From", this->dumper()->getStaticSymbolName(CGPE.cgp_from),
4519 CGPE.cgp_from);
4520 W.printNumber("To", this->dumper()->getStaticSymbolName(CGPE.cgp_to),
4521 CGPE.cgp_to);
4522 W.printNumber("Weight", CGPE.cgp_weight);
4523 }
4524}
4525
4526template <class ELFT>
Peter Collingbourne3e227332018-07-17 22:17:18 +00004527void LLVMStyle<ELFT>::printAddrsig(const ELFFile<ELFT> *Obj) {
4528 ListScope L(W, "Addrsig");
4529 if (!this->dumper()->getDotAddrsigSec())
4530 return;
4531 ArrayRef<uint8_t> Contents = unwrapOrError(
4532 Obj->getSectionContents(this->dumper()->getDotAddrsigSec()));
4533 const uint8_t *Cur = Contents.begin();
4534 const uint8_t *End = Contents.end();
4535 while (Cur != End) {
4536 unsigned Size;
4537 const char *Err;
Peter Collingbourne7d179082018-08-21 17:18:18 +00004538 uint64_t SymIndex = decodeULEB128(Cur, &Size, End, &Err);
Peter Collingbourne3e227332018-07-17 22:17:18 +00004539 if (Err)
4540 reportError(Err);
4541 W.printNumber("Sym", this->dumper()->getStaticSymbolName(SymIndex),
4542 SymIndex);
4543 Cur += Size;
4544 }
4545}
4546
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004547template <typename ELFT>
4548static void printGNUNoteLLVMStyle(uint32_t NoteType,
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004549 ArrayRef<uint8_t> Desc,
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004550 ScopedPrinter &W) {
4551 switch (NoteType) {
4552 default:
4553 return;
4554 case ELF::NT_GNU_ABI_TAG: {
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004555 const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc);
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004556 if (!AbiTag.IsValid) {
4557 W.printString("ABI", "<corrupt GNU_ABI_TAG>");
4558 } else {
4559 W.printString("OS", AbiTag.OSName);
4560 W.printString("ABI", AbiTag.ABI);
4561 }
4562 break;
4563 }
4564 case ELF::NT_GNU_BUILD_ID: {
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004565 W.printString("Build ID", getGNUBuildId(Desc));
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004566 break;
4567 }
4568 case ELF::NT_GNU_GOLD_VERSION:
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004569 W.printString("Version", getGNUGoldVersion(Desc));
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004570 break;
4571 case ELF::NT_GNU_PROPERTY_TYPE_0:
4572 ListScope D(W, "Property");
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004573 for (const auto &Property : getGNUPropertyList<ELFT>(Desc))
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004574 W.printString(Property);
4575 break;
4576 }
4577}
4578
Peter Collingbourne3e227332018-07-17 22:17:18 +00004579template <class ELFT>
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00004580void LLVMStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004581 ListScope L(W, "Notes");
4582 const Elf_Ehdr *e = Obj->getHeader();
4583 bool IsCore = e->e_type == ELF::ET_CORE;
4584
4585 auto PrintHeader = [&](const typename ELFT::Off Offset,
4586 const typename ELFT::Addr Size) {
4587 W.printHex("Offset", Offset);
4588 W.printHex("Size", Size);
4589 };
4590
4591 auto ProcessNote = [&](const Elf_Note &Note) {
4592 DictScope D2(W, "Note");
4593 StringRef Name = Note.getName();
Jake Ehrlichee7ec6c2018-11-13 01:10:35 +00004594 ArrayRef<uint8_t> Descriptor = Note.getDesc();
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004595 Elf_Word Type = Note.getType();
4596
4597 W.printString("Owner", Name);
4598 W.printHex("Data size", Descriptor.size());
4599 if (Name == "GNU") {
4600 W.printString("Type", getGNUNoteTypeName(Type));
4601 printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W);
4602 } else if (Name == "FreeBSD") {
4603 W.printString("Type", getFreeBSDNoteTypeName(Type));
4604 } else if (Name == "AMD") {
Scott Linderf5b36e52018-12-12 19:39:27 +00004605 W.printString("Type", getAMDNoteTypeName(Type));
4606 const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
4607 if (!N.Type.empty())
4608 W.printString(N.Type, N.Value);
4609 } else if (Name == "AMDGPU") {
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004610 W.printString("Type", getAMDGPUNoteTypeName(Type));
4611 const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
Scott Linderf5b36e52018-12-12 19:39:27 +00004612 if (!N.Type.empty())
4613 W.printString(N.Type, N.Value);
Jordan Rupprecht4f36c7a2018-11-07 23:53:50 +00004614 } else {
4615 W.getOStream() << "Unknown note type: (" << format_hex(Type, 10) << ')';
4616 }
4617 };
4618
4619 if (IsCore) {
4620 for (const auto &P : unwrapOrError(Obj->program_headers())) {
4621 if (P.p_type != PT_NOTE)
4622 continue;
4623 DictScope D(W, "NoteSection");
4624 PrintHeader(P.p_offset, P.p_filesz);
4625 Error Err = Error::success();
4626 for (const auto &Note : Obj->notes(P, Err))
4627 ProcessNote(Note);
4628 if (Err)
4629 error(std::move(Err));
4630 }
4631 } else {
4632 for (const auto &S : unwrapOrError(Obj->sections())) {
4633 if (S.sh_type != SHT_NOTE)
4634 continue;
4635 DictScope D(W, "NoteSection");
4636 PrintHeader(S.sh_offset, S.sh_size);
4637 Error Err = Error::success();
4638 for (const auto &Note : Obj->notes(S, Err))
4639 ProcessNote(Note);
4640 if (Err)
4641 error(std::move(Err));
4642 }
4643 }
Saleem Abdulrasool6a405442016-08-30 18:52:02 +00004644}
Simon Atanasyan62d32592017-12-21 10:26:02 +00004645
4646template <class ELFT>
Saleem Abdulrasoolb36fbbc2018-01-30 16:29:29 +00004647void LLVMStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
4648 ListScope L(W, "LinkerOptions");
4649
4650 for (const Elf_Shdr &Shdr : unwrapOrError(Obj->sections())) {
4651 if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS)
4652 continue;
4653
4654 ArrayRef<uint8_t> Contents = unwrapOrError(Obj->getSectionContents(&Shdr));
4655 for (const uint8_t *P = Contents.begin(), *E = Contents.end(); P < E; ) {
4656 StringRef Key = StringRef(reinterpret_cast<const char *>(P));
4657 StringRef Value =
4658 StringRef(reinterpret_cast<const char *>(P) + Key.size() + 1);
4659
4660 W.printString(Key, Value);
4661
4662 P = P + Key.size() + Value.size() + 2;
4663 }
4664 }
4665}
4666
4667template <class ELFT>
Simon Atanasyan62d32592017-12-21 10:26:02 +00004668void LLVMStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
4669 auto PrintEntry = [&](const Elf_Addr *E) {
4670 W.printHex("Address", Parser.getGotAddress(E));
4671 W.printNumber("Access", Parser.getGotOffset(E));
4672 W.printHex("Initial", *E);
4673 };
4674
4675 DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT");
4676
4677 W.printHex("Canonical gp value", Parser.getGp());
4678 {
4679 ListScope RS(W, "Reserved entries");
4680 {
4681 DictScope D(W, "Entry");
4682 PrintEntry(Parser.getGotLazyResolver());
4683 W.printString("Purpose", StringRef("Lazy resolver"));
4684 }
4685
4686 if (Parser.getGotModulePointer()) {
4687 DictScope D(W, "Entry");
4688 PrintEntry(Parser.getGotModulePointer());
4689 W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
4690 }
4691 }
4692 {
4693 ListScope LS(W, "Local entries");
4694 for (auto &E : Parser.getLocalEntries()) {
4695 DictScope D(W, "Entry");
4696 PrintEntry(&E);
4697 }
4698 }
4699
4700 if (Parser.IsStatic)
4701 return;
4702
4703 {
4704 ListScope GS(W, "Global entries");
4705 for (auto &E : Parser.getGlobalEntries()) {
4706 DictScope D(W, "Entry");
4707
4708 PrintEntry(&E);
4709
4710 const Elf_Sym *Sym = Parser.getGotSym(&E);
4711 W.printHex("Value", Sym->st_value);
4712 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
4713
4714 unsigned SectionIndex = 0;
4715 StringRef SectionName;
4716 this->dumper()->getSectionNameIndex(
4717 Sym, this->dumper()->dynamic_symbols().begin(), SectionName,
4718 SectionIndex);
4719 W.printHex("Section", SectionName, SectionIndex);
4720
4721 std::string SymName = this->dumper()->getFullSymbolName(
4722 Sym, this->dumper()->getDynamicStringTable(), true);
4723 W.printNumber("Name", SymName, Sym->st_name);
4724 }
4725 }
4726
4727 W.printNumber("Number of TLS and multi-GOT entries",
Simon Atanasyan4e945b62017-12-21 10:46:20 +00004728 uint64_t(Parser.getOtherEntries().size()));
Simon Atanasyan62d32592017-12-21 10:26:02 +00004729}
4730
4731template <class ELFT>
4732void LLVMStyle<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) {
4733 auto PrintEntry = [&](const Elf_Addr *E) {
4734 W.printHex("Address", Parser.getPltAddress(E));
4735 W.printHex("Initial", *E);
4736 };
4737
4738 DictScope GS(W, "PLT GOT");
4739
4740 {
4741 ListScope RS(W, "Reserved entries");
4742 {
4743 DictScope D(W, "Entry");
4744 PrintEntry(Parser.getPltLazyResolver());
4745 W.printString("Purpose", StringRef("PLT lazy resolver"));
4746 }
4747
4748 if (auto E = Parser.getPltModulePointer()) {
4749 DictScope D(W, "Entry");
4750 PrintEntry(E);
4751 W.printString("Purpose", StringRef("Module pointer"));
4752 }
4753 }
4754 {
4755 ListScope LS(W, "Entries");
4756 for (auto &E : Parser.getPltEntries()) {
4757 DictScope D(W, "Entry");
4758 PrintEntry(&E);
4759
4760 const Elf_Sym *Sym = Parser.getPltSym(&E);
4761 W.printHex("Value", Sym->st_value);
4762 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
4763
4764 unsigned SectionIndex = 0;
4765 StringRef SectionName;
4766 this->dumper()->getSectionNameIndex(
4767 Sym, this->dumper()->dynamic_symbols().begin(), SectionName,
4768 SectionIndex);
4769 W.printHex("Section", SectionName, SectionIndex);
4770
4771 std::string SymName =
4772 this->dumper()->getFullSymbolName(Sym, Parser.getPltStrTable(), true);
4773 W.printNumber("Name", SymName, Sym->st_name);
4774 }
4775 }
4776}