LLVM  13.0.0git
ELFTypes.h
Go to the documentation of this file.
1 //===- ELFTypes.h - Endian specific types for ELF ---------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLVM_OBJECT_ELFTYPES_H
10 #define LLVM_OBJECT_ELFTYPES_H
11 
12 #include "llvm/ADT/ArrayRef.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/BinaryFormat/ELF.h"
15 #include "llvm/Object/Error.h"
16 #include "llvm/Support/Endian.h"
17 #include "llvm/Support/Error.h"
18 #include <cassert>
19 #include <cstdint>
20 #include <cstring>
21 #include <type_traits>
22 
23 namespace llvm {
24 namespace object {
25 
27 
28 template <class ELFT> struct Elf_Ehdr_Impl;
29 template <class ELFT> struct Elf_Shdr_Impl;
30 template <class ELFT> struct Elf_Sym_Impl;
31 template <class ELFT> struct Elf_Dyn_Impl;
32 template <class ELFT> struct Elf_Phdr_Impl;
33 template <class ELFT, bool isRela> struct Elf_Rel_Impl;
34 template <class ELFT> struct Elf_Verdef_Impl;
35 template <class ELFT> struct Elf_Verdaux_Impl;
36 template <class ELFT> struct Elf_Verneed_Impl;
37 template <class ELFT> struct Elf_Vernaux_Impl;
38 template <class ELFT> struct Elf_Versym_Impl;
39 template <class ELFT> struct Elf_Hash_Impl;
40 template <class ELFT> struct Elf_GnuHash_Impl;
41 template <class ELFT> struct Elf_Chdr_Impl;
42 template <class ELFT> struct Elf_Nhdr_Impl;
43 template <class ELFT> class Elf_Note_Impl;
44 template <class ELFT> class Elf_Note_Iterator_Impl;
45 template <class ELFT> struct Elf_CGProfile_Impl;
46 
47 template <endianness E, bool Is64> struct ELFType {
48 private:
49  template <typename Ty>
51 
52 public:
53  static const endianness TargetEndianness = E;
54  static const bool Is64Bits = Is64;
55 
56  using uint = std::conditional_t<Is64, uint64_t, uint32_t>;
64  using Relr = packed<uint>;
84 
90  using Addr = packed<uint>;
91  using Off = packed<uint>;
92 };
93 
98 
99 // Use an alignment of 2 for the typedefs since that is the worst case for
100 // ELF files in archives.
101 
102 // I really don't like doing this, but the alternative is copypasta.
103 #define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \
104  using Elf_Addr = typename ELFT::Addr; \
105  using Elf_Off = typename ELFT::Off; \
106  using Elf_Half = typename ELFT::Half; \
107  using Elf_Word = typename ELFT::Word; \
108  using Elf_Sword = typename ELFT::Sword; \
109  using Elf_Xword = typename ELFT::Xword; \
110  using Elf_Sxword = typename ELFT::Sxword; \
111  using uintX_t = typename ELFT::uint; \
112  using Elf_Ehdr = typename ELFT::Ehdr; \
113  using Elf_Shdr = typename ELFT::Shdr; \
114  using Elf_Sym = typename ELFT::Sym; \
115  using Elf_Dyn = typename ELFT::Dyn; \
116  using Elf_Phdr = typename ELFT::Phdr; \
117  using Elf_Rel = typename ELFT::Rel; \
118  using Elf_Rela = typename ELFT::Rela; \
119  using Elf_Relr = typename ELFT::Relr; \
120  using Elf_Verdef = typename ELFT::Verdef; \
121  using Elf_Verdaux = typename ELFT::Verdaux; \
122  using Elf_Verneed = typename ELFT::Verneed; \
123  using Elf_Vernaux = typename ELFT::Vernaux; \
124  using Elf_Versym = typename ELFT::Versym; \
125  using Elf_Hash = typename ELFT::Hash; \
126  using Elf_GnuHash = typename ELFT::GnuHash; \
127  using Elf_Nhdr = typename ELFT::Nhdr; \
128  using Elf_Note = typename ELFT::Note; \
129  using Elf_Note_Iterator = typename ELFT::NoteIterator; \
130  using Elf_CGProfile = typename ELFT::CGProfile; \
131  using Elf_Dyn_Range = typename ELFT::DynRange; \
132  using Elf_Shdr_Range = typename ELFT::ShdrRange; \
133  using Elf_Sym_Range = typename ELFT::SymRange; \
134  using Elf_Rel_Range = typename ELFT::RelRange; \
135  using Elf_Rela_Range = typename ELFT::RelaRange; \
136  using Elf_Relr_Range = typename ELFT::RelrRange; \
137  using Elf_Phdr_Range = typename ELFT::PhdrRange; \
138 
139 #define LLVM_ELF_COMMA ,
140 #define LLVM_ELF_IMPORT_TYPES(E, W) \
141  LLVM_ELF_IMPORT_TYPES_ELFT(ELFType<E LLVM_ELF_COMMA W>)
142 
143 // Section header.
144 template <class ELFT> struct Elf_Shdr_Base;
145 
146 template <endianness TargetEndianness>
147 struct Elf_Shdr_Base<ELFType<TargetEndianness, false>> {
148  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
149  Elf_Word sh_name; // Section name (index into string table)
150  Elf_Word sh_type; // Section type (SHT_*)
151  Elf_Word sh_flags; // Section flags (SHF_*)
152  Elf_Addr sh_addr; // Address where section is to be loaded
153  Elf_Off sh_offset; // File offset of section data, in bytes
154  Elf_Word sh_size; // Size of section, in bytes
155  Elf_Word sh_link; // Section type-specific header table index link
156  Elf_Word sh_info; // Section type-specific extra information
157  Elf_Word sh_addralign; // Section address alignment
158  Elf_Word sh_entsize; // Size of records contained within the section
159 };
160 
161 template <endianness TargetEndianness>
162 struct Elf_Shdr_Base<ELFType<TargetEndianness, true>> {
163  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
164  Elf_Word sh_name; // Section name (index into string table)
165  Elf_Word sh_type; // Section type (SHT_*)
166  Elf_Xword sh_flags; // Section flags (SHF_*)
167  Elf_Addr sh_addr; // Address where section is to be loaded
168  Elf_Off sh_offset; // File offset of section data, in bytes
169  Elf_Xword sh_size; // Size of section, in bytes
170  Elf_Word sh_link; // Section type-specific header table index link
171  Elf_Word sh_info; // Section type-specific extra information
172  Elf_Xword sh_addralign; // Section address alignment
173  Elf_Xword sh_entsize; // Size of records contained within the section
174 };
175 
176 template <class ELFT>
177 struct Elf_Shdr_Impl : Elf_Shdr_Base<ELFT> {
180 
181  /// Get the number of entities this section contains if it has any.
182  unsigned getEntityCount() const {
183  if (sh_entsize == 0)
184  return 0;
185  return sh_size / sh_entsize;
186  }
187 };
188 
189 template <class ELFT> struct Elf_Sym_Base;
190 
191 template <endianness TargetEndianness>
192 struct Elf_Sym_Base<ELFType<TargetEndianness, false>> {
193  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
194  Elf_Word st_name; // Symbol name (index into string table)
195  Elf_Addr st_value; // Value or address associated with the symbol
196  Elf_Word st_size; // Size of the symbol
197  unsigned char st_info; // Symbol's type and binding attributes
198  unsigned char st_other; // Must be zero; reserved
199  Elf_Half st_shndx; // Which section (header table index) it's defined in
200 };
201 
202 template <endianness TargetEndianness>
203 struct Elf_Sym_Base<ELFType<TargetEndianness, true>> {
204  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
205  Elf_Word st_name; // Symbol name (index into string table)
206  unsigned char st_info; // Symbol's type and binding attributes
207  unsigned char st_other; // Must be zero; reserved
208  Elf_Half st_shndx; // Which section (header table index) it's defined in
209  Elf_Addr st_value; // Value or address associated with the symbol
210  Elf_Xword st_size; // Size of the symbol
211 };
212 
213 template <class ELFT>
214 struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
219 
220  // These accessors and mutators correspond to the ELF32_ST_BIND,
221  // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification:
222  unsigned char getBinding() const { return st_info >> 4; }
223  unsigned char getType() const { return st_info & 0x0f; }
224  uint64_t getValue() const { return st_value; }
225  void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
226  void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
227 
228  void setBindingAndType(unsigned char b, unsigned char t) {
229  st_info = (b << 4) + (t & 0x0f);
230  }
231 
232  /// Access to the STV_xxx flag stored in the first two bits of st_other.
233  /// STV_DEFAULT: 0
234  /// STV_INTERNAL: 1
235  /// STV_HIDDEN: 2
236  /// STV_PROTECTED: 3
237  unsigned char getVisibility() const { return st_other & 0x3; }
238  void setVisibility(unsigned char v) {
239  assert(v < 4 && "Invalid value for visibility");
240  st_other = (st_other & ~0x3) | v;
241  }
242 
243  bool isAbsolute() const { return st_shndx == ELF::SHN_ABS; }
244 
245  bool isCommon() const {
246  return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
247  }
248 
249  bool isDefined() const { return !isUndefined(); }
250 
251  bool isProcessorSpecific() const {
252  return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
253  }
254 
255  bool isOSSpecific() const {
256  return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
257  }
258 
259  bool isReserved() const {
260  // ELF::SHN_HIRESERVE is 0xffff so st_shndx <= ELF::SHN_HIRESERVE is always
261  // true and some compilers warn about it.
262  return st_shndx >= ELF::SHN_LORESERVE;
263  }
264 
265  bool isUndefined() const { return st_shndx == ELF::SHN_UNDEF; }
266 
267  bool isExternal() const {
268  return getBinding() != ELF::STB_LOCAL;
269  }
270 
271  Expected<StringRef> getName(StringRef StrTab) const;
272 };
273 
274 template <class ELFT>
276  uint32_t Offset = this->st_name;
277  if (Offset >= StrTab.size())
279  "st_name (0x%" PRIx32
280  ") is past the end of the string table"
281  " of size 0x%zx",
282  Offset, StrTab.size());
283  return StringRef(StrTab.data() + Offset);
284 }
285 
286 /// Elf_Versym: This is the structure of entries in the SHT_GNU_versym section
287 /// (.gnu.version). This structure is identical for ELF32 and ELF64.
288 template <class ELFT>
289 struct Elf_Versym_Impl {
291  Elf_Half vs_index; // Version index with flags (e.g. VERSYM_HIDDEN)
292 };
293 
294 /// Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section
295 /// (.gnu.version_d). This structure is identical for ELF32 and ELF64.
296 template <class ELFT>
297 struct Elf_Verdef_Impl {
299  Elf_Half vd_version; // Version of this structure (e.g. VER_DEF_CURRENT)
300  Elf_Half vd_flags; // Bitwise flags (VER_DEF_*)
301  Elf_Half vd_ndx; // Version index, used in .gnu.version entries
302  Elf_Half vd_cnt; // Number of Verdaux entries
303  Elf_Word vd_hash; // Hash of name
304  Elf_Word vd_aux; // Offset to the first Verdaux entry (in bytes)
305  Elf_Word vd_next; // Offset to the next Verdef entry (in bytes)
306 
307  /// Get the first Verdaux entry for this Verdef.
308  const Elf_Verdaux *getAux() const {
309  return reinterpret_cast<const Elf_Verdaux *>((const char *)this + vd_aux);
310  }
311 };
312 
313 /// Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef
314 /// section (.gnu.version_d). This structure is identical for ELF32 and ELF64.
315 template <class ELFT>
316 struct Elf_Verdaux_Impl {
318  Elf_Word vda_name; // Version name (offset in string table)
319  Elf_Word vda_next; // Offset to next Verdaux entry (in bytes)
320 };
321 
322 /// Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed
323 /// section (.gnu.version_r). This structure is identical for ELF32 and ELF64.
324 template <class ELFT>
325 struct Elf_Verneed_Impl {
327  Elf_Half vn_version; // Version of this structure (e.g. VER_NEED_CURRENT)
328  Elf_Half vn_cnt; // Number of associated Vernaux entries
329  Elf_Word vn_file; // Library name (string table offset)
330  Elf_Word vn_aux; // Offset to first Vernaux entry (in bytes)
331  Elf_Word vn_next; // Offset to next Verneed entry (in bytes)
332 };
333 
334 /// Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed
335 /// section (.gnu.version_r). This structure is identical for ELF32 and ELF64.
336 template <class ELFT>
337 struct Elf_Vernaux_Impl {
339  Elf_Word vna_hash; // Hash of dependency name
340  Elf_Half vna_flags; // Bitwise Flags (VER_FLAG_*)
341  Elf_Half vna_other; // Version index, used in .gnu.version entries
342  Elf_Word vna_name; // Dependency name
343  Elf_Word vna_next; // Offset to next Vernaux entry (in bytes)
344 };
345 
346 /// Elf_Dyn_Base: This structure matches the form of entries in the dynamic
347 /// table section (.dynamic) look like.
348 template <class ELFT> struct Elf_Dyn_Base;
349 
350 template <endianness TargetEndianness>
351 struct Elf_Dyn_Base<ELFType<TargetEndianness, false>> {
352  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
353  Elf_Sword d_tag;
354  union {
355  Elf_Word d_val;
356  Elf_Addr d_ptr;
357  } d_un;
358 };
359 
360 template <endianness TargetEndianness>
361 struct Elf_Dyn_Base<ELFType<TargetEndianness, true>> {
362  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
363  Elf_Sxword d_tag;
364  union {
365  Elf_Xword d_val;
366  Elf_Addr d_ptr;
367  } d_un;
368 };
369 
370 /// Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters.
371 template <class ELFT>
372 struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> {
373  using Elf_Dyn_Base<ELFT>::d_tag;
374  using Elf_Dyn_Base<ELFT>::d_un;
375  using intX_t = std::conditional_t<ELFT::Is64Bits, int64_t, int32_t>;
376  using uintX_t = std::conditional_t<ELFT::Is64Bits, uint64_t, uint32_t>;
377  intX_t getTag() const { return d_tag; }
378  uintX_t getVal() const { return d_un.d_val; }
379  uintX_t getPtr() const { return d_un.d_ptr; }
380 };
381 
382 template <endianness TargetEndianness>
383 struct Elf_Rel_Impl<ELFType<TargetEndianness, false>, false> {
384  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
385  static const bool IsRela = false;
386  Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
387  Elf_Word r_info; // Symbol table index and type of relocation to apply
388 
389  uint32_t getRInfo(bool isMips64EL) const {
390  assert(!isMips64EL);
391  return r_info;
392  }
393  void setRInfo(uint32_t R, bool IsMips64EL) {
394  assert(!IsMips64EL);
395  r_info = R;
396  }
397 
398  // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
399  // and ELF32_R_INFO macros defined in the ELF specification:
401  return this->getRInfo(isMips64EL) >> 8;
402  }
403  unsigned char getType(bool isMips64EL) const {
404  return (unsigned char)(this->getRInfo(isMips64EL) & 0x0ff);
405  }
406  void setSymbol(uint32_t s, bool IsMips64EL) {
407  setSymbolAndType(s, getType(IsMips64EL), IsMips64EL);
408  }
409  void setType(unsigned char t, bool IsMips64EL) {
410  setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
411  }
412  void setSymbolAndType(uint32_t s, unsigned char t, bool IsMips64EL) {
413  this->setRInfo((s << 8) + t, IsMips64EL);
414  }
415 };
416 
417 template <endianness TargetEndianness>
418 struct Elf_Rel_Impl<ELFType<TargetEndianness, false>, true>
419  : public Elf_Rel_Impl<ELFType<TargetEndianness, false>, false> {
420  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
421  static const bool IsRela = true;
422  Elf_Sword r_addend; // Compute value for relocatable field by adding this
423 };
424 
425 template <endianness TargetEndianness>
426 struct Elf_Rel_Impl<ELFType<TargetEndianness, true>, false> {
427  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
428  static const bool IsRela = false;
429  Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
430  Elf_Xword r_info; // Symbol table index and type of relocation to apply
431 
432  uint64_t getRInfo(bool isMips64EL) const {
433  uint64_t t = r_info;
434  if (!isMips64EL)
435  return t;
436  // Mips64 little endian has a "special" encoding of r_info. Instead of one
437  // 64 bit little endian number, it is a little endian 32 bit number followed
438  // by a 32 bit big endian number.
439  return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) |
440  ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff);
441  }
442 
443  void setRInfo(uint64_t R, bool IsMips64EL) {
444  if (IsMips64EL)
445  r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
446  ((R & 0x0000ff00) << 40) | ((R & 0x000000ff) << 56);
447  else
448  r_info = R;
449  }
450 
451  // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
452  // and ELF64_R_INFO macros defined in the ELF specification:
454  return (uint32_t)(this->getRInfo(isMips64EL) >> 32);
455  }
457  return (uint32_t)(this->getRInfo(isMips64EL) & 0xffffffffL);
458  }
459  void setSymbol(uint32_t s, bool IsMips64EL) {
460  setSymbolAndType(s, getType(IsMips64EL), IsMips64EL);
461  }
462  void setType(uint32_t t, bool IsMips64EL) {
463  setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
464  }
465  void setSymbolAndType(uint32_t s, uint32_t t, bool IsMips64EL) {
466  this->setRInfo(((uint64_t)s << 32) + (t & 0xffffffffL), IsMips64EL);
467  }
468 };
469 
470 template <endianness TargetEndianness>
471 struct Elf_Rel_Impl<ELFType<TargetEndianness, true>, true>
472  : public Elf_Rel_Impl<ELFType<TargetEndianness, true>, false> {
473  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
474  static const bool IsRela = true;
475  Elf_Sxword r_addend; // Compute value for relocatable field by adding this.
476 };
477 
478 template <class ELFT>
479 struct Elf_Ehdr_Impl {
481  unsigned char e_ident[ELF::EI_NIDENT]; // ELF Identification bytes
482  Elf_Half e_type; // Type of file (see ET_*)
483  Elf_Half e_machine; // Required architecture for this file (see EM_*)
484  Elf_Word e_version; // Must be equal to 1
485  Elf_Addr e_entry; // Address to jump to in order to start program
486  Elf_Off e_phoff; // Program header table's file offset, in bytes
487  Elf_Off e_shoff; // Section header table's file offset, in bytes
488  Elf_Word e_flags; // Processor-specific flags
489  Elf_Half e_ehsize; // Size of ELF header, in bytes
490  Elf_Half e_phentsize; // Size of an entry in the program header table
491  Elf_Half e_phnum; // Number of entries in the program header table
492  Elf_Half e_shentsize; // Size of an entry in the section header table
493  Elf_Half e_shnum; // Number of entries in the section header table
494  Elf_Half e_shstrndx; // Section header table index of section name
495  // string table
496 
497  bool checkMagic() const {
498  return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
499  }
500 
501  unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; }
502  unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; }
503 };
504 
505 template <endianness TargetEndianness>
506 struct Elf_Phdr_Impl<ELFType<TargetEndianness, false>> {
507  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
508  Elf_Word p_type; // Type of segment
509  Elf_Off p_offset; // FileOffset where segment is located, in bytes
510  Elf_Addr p_vaddr; // Virtual Address of beginning of segment
511  Elf_Addr p_paddr; // Physical address of beginning of segment (OS-specific)
512  Elf_Word p_filesz; // Num. of bytes in file image of segment (may be zero)
513  Elf_Word p_memsz; // Num. of bytes in mem image of segment (may be zero)
514  Elf_Word p_flags; // Segment flags
515  Elf_Word p_align; // Segment alignment constraint
516 };
517 
518 template <endianness TargetEndianness>
519 struct Elf_Phdr_Impl<ELFType<TargetEndianness, true>> {
520  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
521  Elf_Word p_type; // Type of segment
522  Elf_Word p_flags; // Segment flags
523  Elf_Off p_offset; // FileOffset where segment is located, in bytes
524  Elf_Addr p_vaddr; // Virtual Address of beginning of segment
525  Elf_Addr p_paddr; // Physical address of beginning of segment (OS-specific)
526  Elf_Xword p_filesz; // Num. of bytes in file image of segment (may be zero)
527  Elf_Xword p_memsz; // Num. of bytes in mem image of segment (may be zero)
528  Elf_Xword p_align; // Segment alignment constraint
529 };
530 
531 // ELFT needed for endianness.
532 template <class ELFT>
533 struct Elf_Hash_Impl {
535  Elf_Word nbucket;
536  Elf_Word nchain;
537 
538  ArrayRef<Elf_Word> buckets() const {
539  return ArrayRef<Elf_Word>(&nbucket + 2, &nbucket + 2 + nbucket);
540  }
541 
543  return ArrayRef<Elf_Word>(&nbucket + 2 + nbucket,
544  &nbucket + 2 + nbucket + nchain);
545  }
546 };
547 
548 // .gnu.hash section
549 template <class ELFT>
550 struct Elf_GnuHash_Impl {
552  Elf_Word nbuckets;
553  Elf_Word symndx;
554  Elf_Word maskwords;
555  Elf_Word shift2;
556 
557  ArrayRef<Elf_Off> filter() const {
558  return ArrayRef<Elf_Off>(reinterpret_cast<const Elf_Off *>(&shift2 + 1),
559  maskwords);
560  }
561 
563  return ArrayRef<Elf_Word>(
564  reinterpret_cast<const Elf_Word *>(filter().end()), nbuckets);
565  }
566 
567  ArrayRef<Elf_Word> values(unsigned DynamicSymCount) const {
568  assert(DynamicSymCount >= symndx);
569  return ArrayRef<Elf_Word>(buckets().end(), DynamicSymCount - symndx);
570  }
571 };
572 
573 // Compressed section headers.
574 // http://www.sco.com/developers/gabi/latest/ch4.sheader.html#compression_header
575 template <endianness TargetEndianness>
576 struct Elf_Chdr_Impl<ELFType<TargetEndianness, false>> {
577  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
578  Elf_Word ch_type;
579  Elf_Word ch_size;
580  Elf_Word ch_addralign;
581 };
582 
583 template <endianness TargetEndianness>
584 struct Elf_Chdr_Impl<ELFType<TargetEndianness, true>> {
585  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
586  Elf_Word ch_type;
587  Elf_Word ch_reserved;
588  Elf_Xword ch_size;
589  Elf_Xword ch_addralign;
590 };
591 
592 /// Note header
593 template <class ELFT>
594 struct Elf_Nhdr_Impl {
596  Elf_Word n_namesz;
597  Elf_Word n_descsz;
598  Elf_Word n_type;
599 
600  /// The alignment of the name and descriptor.
601  ///
602  /// Implementations differ from the specification here: in practice all
603  /// variants align both the name and descriptor to 4-bytes.
604  static const unsigned int Align = 4;
605 
606  /// Get the size of the note, including name, descriptor, and padding.
607  size_t getSize() const {
608  return sizeof(*this) + alignTo<Align>(n_namesz) + alignTo<Align>(n_descsz);
609  }
610 };
611 
612 /// An ELF note.
613 ///
614 /// Wraps a note header, providing methods for accessing the name and
615 /// descriptor safely.
616 template <class ELFT>
617 class Elf_Note_Impl {
619 
620  const Elf_Nhdr_Impl<ELFT> &Nhdr;
621 
622  template <class NoteIteratorELFT> friend class Elf_Note_Iterator_Impl;
623 
624 public:
625  Elf_Note_Impl(const Elf_Nhdr_Impl<ELFT> &Nhdr) : Nhdr(Nhdr) {}
626 
627  /// Get the note's name, excluding the terminating null byte.
628  StringRef getName() const {
629  if (!Nhdr.n_namesz)
630  return StringRef();
631  return StringRef(reinterpret_cast<const char *>(&Nhdr) + sizeof(Nhdr),
632  Nhdr.n_namesz - 1);
633  }
634 
635  /// Get the note's descriptor.
637  if (!Nhdr.n_descsz)
638  return ArrayRef<uint8_t>();
639  return ArrayRef<uint8_t>(
640  reinterpret_cast<const uint8_t *>(&Nhdr) + sizeof(Nhdr) +
641  alignTo<Elf_Nhdr_Impl<ELFT>::Align>(Nhdr.n_namesz),
642  Nhdr.n_descsz);
643  }
644 
645  /// Get the note's descriptor as StringRef
647  ArrayRef<uint8_t> Desc = getDesc();
648  return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
649  }
650 
651  /// Get the note's type.
652  Elf_Word getType() const { return Nhdr.n_type; }
653 };
654 
655 template <class ELFT>
656 class Elf_Note_Iterator_Impl
657  : std::iterator<std::forward_iterator_tag, Elf_Note_Impl<ELFT>> {
658  // Nhdr being a nullptr marks the end of iteration.
659  const Elf_Nhdr_Impl<ELFT> *Nhdr = nullptr;
660  size_t RemainingSize = 0u;
661  Error *Err = nullptr;
662 
663  template <class ELFFileELFT> friend class ELFFile;
664 
665  // Stop iteration and indicate an overflow.
666  void stopWithOverflowError() {
667  Nhdr = nullptr;
668  *Err = make_error<StringError>("ELF note overflows container",
670  }
671 
672  // Advance Nhdr by NoteSize bytes, starting from NhdrPos.
673  //
674  // Assumes NoteSize <= RemainingSize. Ensures Nhdr->getSize() <= RemainingSize
675  // upon returning. Handles stopping iteration when reaching the end of the
676  // container, either cleanly or with an overflow error.
677  void advanceNhdr(const uint8_t *NhdrPos, size_t NoteSize) {
678  RemainingSize -= NoteSize;
679  if (RemainingSize == 0u) {
680  // Ensure that if the iterator walks to the end, the error is checked
681  // afterwards.
682  *Err = Error::success();
683  Nhdr = nullptr;
684  } else if (sizeof(*Nhdr) > RemainingSize)
685  stopWithOverflowError();
686  else {
687  Nhdr = reinterpret_cast<const Elf_Nhdr_Impl<ELFT> *>(NhdrPos + NoteSize);
688  if (Nhdr->getSize() > RemainingSize)
689  stopWithOverflowError();
690  else
691  *Err = Error::success();
692  }
693  }
694 
695  Elf_Note_Iterator_Impl() {}
696  explicit Elf_Note_Iterator_Impl(Error &Err) : Err(&Err) {}
697  Elf_Note_Iterator_Impl(const uint8_t *Start, size_t Size, Error &Err)
698  : RemainingSize(Size), Err(&Err) {
699  consumeError(std::move(Err));
700  assert(Start && "ELF note iterator starting at NULL");
701  advanceNhdr(Start, 0u);
702  }
703 
704 public:
706  assert(Nhdr && "incremented ELF note end iterator");
707  const uint8_t *NhdrPos = reinterpret_cast<const uint8_t *>(Nhdr);
708  size_t NoteSize = Nhdr->getSize();
709  advanceNhdr(NhdrPos, NoteSize);
710  return *this;
711  }
713  if (!Nhdr && Other.Err)
714  (void)(bool)(*Other.Err);
715  if (!Other.Nhdr && Err)
716  (void)(bool)(*Err);
717  return Nhdr == Other.Nhdr;
718  }
720  return !(*this == Other);
721  }
723  assert(Nhdr && "dereferenced ELF note end iterator");
724  return Elf_Note_Impl<ELFT>(*Nhdr);
725  }
726 };
727 
728 template <class ELFT> struct Elf_CGProfile_Impl {
730  Elf_Word cgp_from;
731  Elf_Word cgp_to;
732  Elf_Xword cgp_weight;
733 };
734 
735 // MIPS .reginfo section
736 template <class ELFT>
738 
739 template <support::endianness TargetEndianness>
740 struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
741  LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
742  Elf_Word ri_gprmask; // bit-mask of used general registers
743  Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers
744  Elf_Addr ri_gp_value; // gp register value
745 };
746 
747 template <support::endianness TargetEndianness>
748 struct Elf_Mips_RegInfo<ELFType<TargetEndianness, true>> {
749  LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
750  Elf_Word ri_gprmask; // bit-mask of used general registers
751  Elf_Word ri_pad; // unused padding field
752  Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers
753  Elf_Addr ri_gp_value; // gp register value
754 };
755 
756 // .MIPS.options section
757 template <class ELFT> struct Elf_Mips_Options {
759  uint8_t kind; // Determines interpretation of variable part of descriptor
760  uint8_t size; // Byte size of descriptor, including this header
761  Elf_Half section; // Section header index of section affected,
762  // or 0 for global options
763  Elf_Word info; // Kind-specific information
764 
765  Elf_Mips_RegInfo<ELFT> &getRegInfo() {
766  assert(kind == ELF::ODK_REGINFO);
767  return *reinterpret_cast<Elf_Mips_RegInfo<ELFT> *>(
768  (uint8_t *)this + sizeof(Elf_Mips_Options));
769  }
771  return const_cast<Elf_Mips_Options *>(this)->getRegInfo();
772  }
773 };
774 
775 // .MIPS.abiflags section content
776 template <class ELFT> struct Elf_Mips_ABIFlags {
778  Elf_Half version; // Version of the structure
779  uint8_t isa_level; // ISA level: 1-5, 32, and 64
780  uint8_t isa_rev; // ISA revision (0 for MIPS I - MIPS V)
781  uint8_t gpr_size; // General purpose registers size
782  uint8_t cpr1_size; // Co-processor 1 registers size
783  uint8_t cpr2_size; // Co-processor 2 registers size
784  uint8_t fp_abi; // Floating-point ABI flag
785  Elf_Word isa_ext; // Processor-specific extension
786  Elf_Word ases; // ASEs flags
787  Elf_Word flags1; // General flags
788  Elf_Word flags2; // General flags
789 };
790 
791 } // end namespace object.
792 } // end namespace llvm.
793 
794 #endif // LLVM_OBJECT_ELFTYPES_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::object::Elf_Mips_Options::getRegInfo
const Elf_Mips_RegInfo< ELFT > & getRegInfo() const
Definition: ELFTypes.h:770
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:158
llvm::object::Elf_Chdr_Impl
Definition: ELFTypes.h:41
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::getSymbol
uint32_t getSymbol(bool isMips64EL) const
Definition: ELFTypes.h:400
getName
static StringRef getName(Value *V)
Definition: ProvenanceAnalysisEvaluator.cpp:42
llvm
This class represents lattice values for constants.
Definition: AllocatorList.h:23
llvm::HexagonMCInstrInfo::getDesc
const MCInstrDesc & getDesc(MCInstrInfo const &MCII, MCInst const &MCI)
Definition: HexagonMCInstrInfo.cpp:248
llvm::object::Elf_Shdr_Impl::getEntityCount
unsigned getEntityCount() const
Get the number of entities this section contains if it has any.
Definition: ELFTypes.h:182
llvm::lltok::Error
@ Error
Definition: LLToken.h:21
endianness
llvm::support::endianness endianness
Definition: BinaryStreamReader.cpp:16
llvm::object::Elf_Ehdr_Impl
Definition: ELFTypes.h:28
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::setSymbolAndType
void setSymbolAndType(uint32_t s, uint32_t t, bool IsMips64EL)
Definition: ELFTypes.h:465
llvm::support::detail::packed_endian_specific_integral
Definition: Endian.h:206
StringRef.h
llvm::object::ELFType::TargetEndianness
static const endianness TargetEndianness
Definition: ELFTypes.h:53
llvm::object::Elf_Sym_Impl::getType
unsigned char getType() const
Definition: ELFTypes.h:223
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::object::Elf_Dyn_Impl
Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters.
Definition: ELFTypes.h:31
llvm::object::Elf_Sym_Impl::isOSSpecific
bool isOSSpecific() const
Definition: ELFTypes.h:255
llvm::ELF::EI_DATA
@ EI_DATA
Definition: ELF.h:52
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:928
Error.h
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::getType
uint32_t getType(bool isMips64EL) const
Definition: ELFTypes.h:456
llvm::ELF::SHN_COMMON
@ SHN_COMMON
Definition: ELF.h:841
llvm::object::Elf_Rel_Impl
Definition: ELFTypes.h:33
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::setRInfo
void setRInfo(uint32_t R, bool IsMips64EL)
Definition: ELFTypes.h:393
llvm::object::ELFType::Is64Bits
static const bool Is64Bits
Definition: ELFTypes.h:54
LLVM_ELF_IMPORT_TYPES
#define LLVM_ELF_IMPORT_TYPES(E, W)
Definition: ELFTypes.h:140
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::setSymbol
void setSymbol(uint32_t s, bool IsMips64EL)
Definition: ELFTypes.h:406
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
llvm::object::Elf_Sym_Impl::getValue
uint64_t getValue() const
Definition: ELFTypes.h:224
llvm::object::Elf_Mips_ABIFlags
Definition: ELFTypes.h:776
llvm::object::Elf_Dyn_Impl::getVal
uintX_t getVal() const
Definition: ELFTypes.h:378
llvm::object::Elf_Note_Impl::Elf_Note_Impl
Elf_Note_Impl(const Elf_Nhdr_Impl< ELFT > &Nhdr)
Definition: ELFTypes.h:625
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
getType
static wasm::ValType getType(const TargetRegisterClass *RC)
Definition: WebAssemblyMCInstLower.cpp:188
llvm::object::Elf_Verdaux_Impl
Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef section (....
Definition: ELFTypes.h:35
llvm::object::Elf_Sym_Impl::getVisibility
unsigned char getVisibility() const
Access to the STV_xxx flag stored in the first two bits of st_other.
Definition: ELFTypes.h:237
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1006
llvm::ELF::ODK_REGINFO
@ ODK_REGINFO
Definition: ELF.h:574
llvm::object::Elf_Note_Iterator_Impl::operator!=
bool operator!=(Elf_Note_Iterator_Impl Other) const
Definition: ELFTypes.h:719
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:153
llvm::object::Elf_Hash_Impl
Definition: ELFTypes.h:39
llvm::object::Elf_Sym_Impl::setType
void setType(unsigned char t)
Definition: ELFTypes.h:226
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:834
llvm::object::ELFType
Definition: ELFTypes.h:47
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::setSymbolAndType
void setSymbolAndType(uint32_t s, unsigned char t, bool IsMips64EL)
Definition: ELFTypes.h:412
llvm::object::Elf_Versym_Impl
Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version).
Definition: ELFTypes.h:38
Error.h
ELF.h
llvm::ELF::EI_CLASS
@ EI_CLASS
Definition: ELF.h:51
llvm::object::Elf_Sym_Impl::getName
Expected< StringRef > getName(StringRef StrTab) const
Definition: ELFTypes.h:275
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::object::Elf_Sym_Impl::isDefined
bool isDefined() const
Definition: ELFTypes.h:249
llvm::object::Elf_Dyn_Impl::intX_t
std::conditional_t< ELFT::Is64Bits, int64_t, int32_t > intX_t
Definition: ELFTypes.h:375
llvm::object::Elf_GnuHash_Impl::buckets
ArrayRef< Elf_Word > buckets() const
Definition: ELFTypes.h:562
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1077
t
bitcast float %x to i32 %s=and i32 %t, 2147483647 %d=bitcast i32 %s to float ret float %d } declare float @fabsf(float %n) define float @bar(float %x) nounwind { %d=call float @fabsf(float %x) ret float %d } This IR(from PR6194):target datalayout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple="x86_64-apple-darwin10.0.0" %0=type { double, double } %struct.float3=type { float, float, float } define void @test(%0, %struct.float3 *nocapture %res) nounwind noinline ssp { entry:%tmp18=extractvalue %0 %0, 0 t
Definition: README-SSE.txt:788
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
false
Definition: StackSlotColoring.cpp:142
llvm::ELF::EI_NIDENT
@ EI_NIDENT
Definition: ELF.h:57
llvm::object::object_error::parse_failed
@ parse_failed
llvm::object::Elf_Mips_RegInfo
Definition: ELFTypes.h:737
llvm::object::Elf_Shdr_Impl
Definition: ELFTypes.h:29
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::object::Elf_Sym_Impl::isReserved
bool isReserved() const
Definition: ELFTypes.h:259
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, true > >::d_val
Elf_Xword d_val
Definition: ELFTypes.h:365
llvm::object::Elf_Sym_Impl::setBinding
void setBinding(unsigned char b)
Definition: ELFTypes.h:225
llvm::ELF::SHN_LOOS
@ SHN_LOOS
Definition: ELF.h:838
object
bar al al movzbl eax ret Missed when stored in a memory object
Definition: README.txt:1411
llvm::object::Elf_Phdr_Impl
Definition: ELFTypes.h:32
llvm::object::Elf_Sym_Impl::isUndefined
bool isUndefined() const
Definition: ELFTypes.h:265
llvm::object::Elf_Sym_Impl::isAbsolute
bool isAbsolute() const
Definition: ELFTypes.h:243
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::object::ELFType::uint
std::conditional_t< Is64, uint64_t, uint32_t > uint
Definition: ELFTypes.h:56
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::object::Elf_Dyn_Base
Elf_Dyn_Base: This structure matches the form of entries in the dynamic table section (....
Definition: ELFTypes.h:348
ArrayRef.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::object::Elf_Verneed_Impl
Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed section (.gnu....
Definition: ELFTypes.h:36
llvm::ELF::STT_COMMON
@ STT_COMMON
Definition: ELF.h:1094
isMips64EL
static bool isMips64EL(const ELFYAML::Object &Obj)
Definition: ELFEmitter.cpp:1219
llvm::object::Elf_Note_Iterator_Impl::operator*
Elf_Note_Impl< ELFT > operator*() const
Definition: ELFTypes.h:722
llvm::object::Elf_CGProfile_Impl
Definition: ELFTypes.h:45
llvm::object::Elf_Nhdr_Impl::n_descsz
Elf_Word n_descsz
Definition: ELFTypes.h:597
llvm::object::Elf_Sym_Impl::setVisibility
void setVisibility(unsigned char v)
Definition: ELFTypes.h:238
info
lazy value info
Definition: LazyValueInfo.cpp:59
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::setRInfo
void setRInfo(uint64_t R, bool IsMips64EL)
Definition: ELFTypes.h:443
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1479
llvm::object::Elf_Note_Iterator_Impl::operator==
bool operator==(Elf_Note_Iterator_Impl Other) const
Definition: ELFTypes.h:712
llvm::object::Elf_Shdr_Base
Definition: ELFTypes.h:144
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::getSymbol
uint32_t getSymbol(bool isMips64EL) const
Definition: ELFTypes.h:453
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::object::Elf_Hash_Impl::chains
ArrayRef< Elf_Word > chains() const
Definition: ELFTypes.h:542
uint32_t
llvm::object::Elf_Sym_Impl
Definition: ELFTypes.h:30
llvm::object::Elf_Note_Iterator_Impl
Definition: ELFTypes.h:44
llvm::object::Elf_Sym_Base
Definition: ELFTypes.h:189
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, false > >::d_val
Elf_Word d_val
Definition: ELFTypes.h:355
llvm::object::Elf_Sym_Impl::isProcessorSpecific
bool isProcessorSpecific() const
Definition: ELFTypes.h:251
llvm::object::Elf_Note_Impl::getDescAsStringRef
StringRef getDescAsStringRef() const
Get the note's descriptor as StringRef.
Definition: ELFTypes.h:646
llvm::ELF::SHN_HIOS
@ SHN_HIOS
Definition: ELF.h:839
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::setType
void setType(unsigned char t, bool IsMips64EL)
Definition: ELFTypes.h:409
llvm::object::Elf_Ehdr_Impl::getDataEncoding
unsigned char getDataEncoding() const
Definition: ELFTypes.h:502
LLVM_ELF_IMPORT_TYPES_ELFT
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
Definition: ELFTypes.h:103
llvm::object::Elf_Sym_Impl::getBinding
unsigned char getBinding() const
Definition: ELFTypes.h:222
llvm::ELF::SHN_ABS
@ SHN_ABS
Definition: ELF.h:840
llvm::object::Elf_Verdef_Impl
Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d).
Definition: ELFTypes.h:34
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1202
llvm::object::Elf_Sym_Impl::isCommon
bool isCommon() const
Definition: ELFTypes.h:245
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::object::Elf_Mips_Options
Definition: ELFTypes.h:757
llvm::ELF::SHN_LOPROC
@ SHN_LOPROC
Definition: ELF.h:836
llvm::object::Elf_Note_Iterator_Impl::operator++
Elf_Note_Iterator_Impl & operator++()
Definition: ELFTypes.h:705
llvm::object::Elf_Vernaux_Impl
Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed section (....
Definition: ELFTypes.h:37
llvm::object::Elf_Note_Impl::getDesc
ArrayRef< uint8_t > getDesc() const
Get the note's descriptor.
Definition: ELFTypes.h:636
llvm::ELF::SHN_HIPROC
@ SHN_HIPROC
Definition: ELF.h:837
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, false >::getType
unsigned char getType(bool isMips64EL) const
Definition: ELFTypes.h:403
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::setType
void setType(uint32_t t, bool IsMips64EL)
Definition: ELFTypes.h:462
llvm::ELF::SHN_LORESERVE
@ SHN_LORESERVE
Definition: ELF.h:835
llvm::object::Elf_Sym_Impl::isExternal
bool isExternal() const
Definition: ELFTypes.h:267
llvm::object::Elf_GnuHash_Impl::values
ArrayRef< Elf_Word > values(unsigned DynamicSymCount) const
Definition: ELFTypes.h:567
llvm::ELF::ElfMagic
static const char ElfMagic[]
Definition: ELF.h:43
llvm::object::Elf_Dyn_Impl::uintX_t
std::conditional_t< ELFT::Is64Bits, uint64_t, uint32_t > uintX_t
Definition: ELFTypes.h:376
llvm::object::Elf_Sym_Impl::setBindingAndType
void setBindingAndType(unsigned char b, unsigned char t)
Definition: ELFTypes.h:228
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:156
support
Reimplement select in terms of SEL *We would really like to support but we need to prove that the add doesn t need to overflow between the two bit chunks *Implement pre post increment support(e.g. PR935) *Implement smarter const ant generation for binops with large immediates. A few ARMv6T2 ops should be pattern matched
Definition: README.txt:10
llvm::object::Elf_GnuHash_Impl
Definition: ELFTypes.h:40
llvm::support::endianness
endianness
Definition: Endian.h:27
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:152
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, false >::setSymbol
void setSymbol(uint32_t s, bool IsMips64EL)
Definition: ELFTypes.h:459
llvm::object::Elf_Dyn_Impl::getTag
intX_t getTag() const
Definition: ELFTypes.h:377
llvm::object::Elf_Note_Impl
An ELF note.
Definition: ELFTypes.h:43
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, true > >::d_ptr
Elf_Addr d_ptr
Definition: ELFTypes.h:366
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, false > >::d_ptr
Elf_Addr d_ptr
Definition: ELFTypes.h:356
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:160
Endian.h
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1833
llvm::object::Elf_Ehdr_Impl::getFileClass
unsigned char getFileClass() const
Definition: ELFTypes.h:501
llvm::object::ELFFile
Definition: ELF.h:95
llvm::object::Elf_Note_Impl::getName
StringRef getName() const
Get the note's name, excluding the terminating null byte.
Definition: ELFTypes.h:628
llvm::object::Elf_Note_Impl::getType
Elf_Word getType() const
Get the note's type.
Definition: ELFTypes.h:652
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1131
llvm::object::Elf_Nhdr_Impl
Note header.
Definition: ELFTypes.h:42
llvm::object::Elf_Dyn_Impl::getPtr
uintX_t getPtr() const
Definition: ELFTypes.h:379