contrib/llvm/tools/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h

   1 //===-- ELFHeader.h ------------------------------------------- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// @file
  11 /// @brief Generic structures and typedefs for ELF files.
  12 ///
  13 /// This file provides definitions for the various entities comprising an ELF
  14 /// file.  The structures are generic in the sense that they do not correspond
  15 /// to the exact binary layout of an ELF, but can be used to hold the
  16 /// information present in both 32 and 64 bit variants of the format.  Each
  17 /// entity provides a \c Parse method which is capable of transparently reading
  18 /// both 32 and 64 bit instances of the object.
  19 //===----------------------------------------------------------------------===//
  20
  21 #ifndef liblldb_ELFHeader_h_
  22 #define liblldb_ELFHeader_h_
  23
  24 #include "llvm/Support/ELF.h"
  25
  26 #include "lldb/lldb-enumerations.h"
  27
  28 namespace lldb_private
  29 {
  30 class DataExtractor;
  31 } // End namespace lldb_private.
  32
  33 namespace elf
  34 {
  35
  36 //------------------------------------------------------------------------------
  37 /// @name ELF type definitions.
  38 ///
  39 /// Types used to represent the various components of ELF structures.  All types
  40 /// are signed or unsigned integral types wide enough to hold values from both
  41 /// 32 and 64 bit ELF variants.
  42 //@{
  43 typedef uint64_t elf_addr;
  44 typedef uint64_t elf_off;
  45 typedef uint16_t elf_half;
  46 typedef uint32_t elf_word;
  47 typedef int32_t  elf_sword;
  48 typedef uint64_t elf_size;
  49 typedef uint64_t elf_xword;
  50 typedef int64_t  elf_sxword;
  51 //@}
  52
  53 //------------------------------------------------------------------------------
  54 /// @class ELFHeader
  55 /// @brief Generic representation of an ELF file header.
  56 ///
  57 /// This object is used to identify the general attributes on an ELF file and to
  58 /// locate additional sections within the file.
  59 struct ELFHeader
  60 {
  61     unsigned char e_ident[llvm::ELF::EI_NIDENT]; ///< ELF file identification.
  62     elf_addr      e_entry;            ///< Virtual address program entry point.
  63     elf_off       e_phoff;            ///< File offset of program header table.
  64     elf_off       e_shoff;            ///< File offset of section header table.
  65     elf_word      e_flags;            ///< Processor specific flags.
  66     elf_word      e_version;          ///< Version of object file (always 1).
  67     elf_half      e_type;             ///< Object file type.
  68     elf_half      e_machine;          ///< Target architecture.
  69     elf_half      e_ehsize;           ///< Byte size of the ELF header.
  70     elf_half      e_phentsize;        ///< Size of a program header table entry.
  71     elf_half      e_phnum;            ///< Number of program header entries.
  72     elf_half      e_shentsize;        ///< Size of a section header table entry.
  73     elf_half      e_shnum;            ///< Number of section header entries.
  74     elf_half      e_shstrndx;         ///< String table section index.
  75
  76     ELFHeader();
  77
  78     //--------------------------------------------------------------------------
  79     /// Returns true if this is a 32 bit ELF file header.
  80     ///
  81     /// @return
  82     ///    True if this is a 32 bit ELF file header.
  83     bool Is32Bit() const {
  84         return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS32;
  85     }
  86
  87     //--------------------------------------------------------------------------
  88     /// Returns true if this is a 64 bit ELF file header.
  89     ///
  90     /// @return
  91     ///   True if this is a 64 bit ELF file header.
  92     bool Is64Bit() const {
  93         return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS64;
  94     }
  95
  96     //--------------------------------------------------------------------------
  97     /// The byte order of this ELF file header.
  98     ///
  99     /// @return
 100     ///    The byte order of this ELF file as described by the header.
 101     lldb::ByteOrder
 102     GetByteOrder() const;
 103
 104     //--------------------------------------------------------------------------
 105     /// The jump slot relocation type of this ELF.
 106     unsigned
 107     GetRelocationJumpSlotType() const;
 108
 109     //--------------------------------------------------------------------------
 110     /// Parse an ELFHeader entry starting at position \p offset and
 111     /// update the data extractor with the address size and byte order
 112     /// attributes as defined by the header.
 113     ///
 114     /// @param[in,out] data
 115     ///    The DataExtractor to read from.  Updated with the address size and
 116     ///    byte order attributes appropriate to this header.
 117     ///
 118     /// @param[in,out] offset
 119     ///    Pointer to an offset in the data.  On return the offset will be
 120     ///    advanced by the number of bytes read.
 121     ///
 122     /// @return
 123     ///    True if the ELFHeader was successfully read and false
 124     ///    otherwise.
 125     bool
 126     Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset);
 127
 128     //--------------------------------------------------------------------------
 129     /// Examines at most EI_NIDENT bytes starting from the given pointer and
 130     /// determines if the magic ELF identification exists.
 131     ///
 132     /// @return
 133     ///    True if the given sequence of bytes identifies an ELF file.
 134     static bool
 135     MagicBytesMatch(const uint8_t *magic);
 136
 137     //--------------------------------------------------------------------------
 138     /// Examines at most EI_NIDENT bytes starting from the given address and
 139     /// determines the address size of the underlying ELF file.  This function
 140     /// should only be called on an pointer for which MagicBytesMatch returns
 141     /// true.
 142     ///
 143     /// @return
 144     ///    The number of bytes forming an address in the ELF file (either 4 or
 145     ///    8), else zero if the address size could not be determined.
 146     static unsigned
 147     AddressSizeInBytes(const uint8_t *magic);
 148 };
 149
 150 //------------------------------------------------------------------------------
 151 /// @class ELFSectionHeader
 152 /// @brief Generic representation of an ELF section header.
 153 struct ELFSectionHeader
 154 {
 155     elf_word  sh_name;          ///< Section name string index.
 156     elf_word  sh_type;          ///< Section type.
 157     elf_xword sh_flags;         ///< Section attributes.
 158     elf_addr  sh_addr;          ///< Virtual address of the section in memory.
 159     elf_off   sh_offset;        ///< Start of section from beginning of file.
 160     elf_xword sh_size;          ///< Number of bytes occupied in the file.
 161     elf_word  sh_link;          ///< Index of associated section.
 162     elf_word  sh_info;          ///< Extra section info (overloaded).
 163     elf_xword sh_addralign;     ///< Power of two alignment constraint.
 164     elf_xword sh_entsize;       ///< Byte size of each section entry.
 165
 166     ELFSectionHeader();
 167
 168     //--------------------------------------------------------------------------
 169     /// Parse an ELFSectionHeader entry from the given DataExtracter starting at
 170     /// position \p offset.
 171     ///
 172     /// @param[in] data
 173     ///    The DataExtractor to read from.  The address size of the extractor
 174     ///    determines if a 32 or 64 bit object should be read.
 175     ///
 176     /// @param[in,out] offset
 177     ///    Pointer to an offset in the data.  On return the offset will be
 178     ///    advanced by the number of bytes read.
 179     ///
 180     /// @return
 181     ///    True if the ELFSectionHeader was successfully read and false
 182     ///    otherwise.
 183     bool
 184     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 185 };
 186
 187 //------------------------------------------------------------------------------
 188 /// @class ELFProgramHeader
 189 /// @brief Generic representation of an ELF program header.
 190 struct ELFProgramHeader
 191 {
 192     elf_word  p_type;           ///< Type of program segment.
 193     elf_word  p_flags;          ///< Segment attributes.
 194     elf_off   p_offset;         ///< Start of segment from beginning of file.
 195     elf_addr  p_vaddr;          ///< Virtual address of segment in memory.
 196     elf_addr  p_paddr;          ///< Physical address (for non-VM systems).
 197     elf_xword p_filesz;         ///< Byte size of the segment in file.
 198     elf_xword p_memsz;          ///< Byte size of the segment in memory.
 199     elf_xword p_align;          ///< Segment alignment constraint.
 200
 201     ELFProgramHeader();
 202
 203     /// Parse an ELFProgramHeader entry from the given DataExtractor starting at
 204     /// position \p offset.  The address size of the DataExtractor determines if
 205     /// a 32 or 64 bit object is to be parsed.
 206     ///
 207     /// @param[in] data
 208     ///    The DataExtractor to read from.  The address size of the extractor
 209     ///    determines if a 32 or 64 bit object should be read.
 210     ///
 211     /// @param[in,out] offset
 212     ///    Pointer to an offset in the data.  On return the offset will be
 213     ///    advanced by the number of bytes read.
 214     ///
 215     /// @return
 216     ///    True if the ELFProgramHeader was successfully read and false
 217     ///    otherwise.
 218     bool
 219     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 220 };
 221
 222 //------------------------------------------------------------------------------
 223 /// @class ELFSymbol
 224 /// @brief Represents a symbol within an ELF symbol table.
 225 struct ELFSymbol
 226 {
 227     elf_addr      st_value;     ///< Absolute or relocatable address.
 228     elf_xword     st_size;      ///< Size of the symbol or zero.
 229     elf_word      st_name;      ///< Symbol name string index.
 230     unsigned char st_info;      ///< Symbol type and binding attributes.
 231     unsigned char st_other;     ///< Reserved for future use.
 232     elf_half      st_shndx;     ///< Section to which this symbol applies.
 233
 234     ELFSymbol();
 235
 236     /// Returns the binding attribute of the st_info member.
 237     unsigned char getBinding() const { return st_info >> 4; }
 238
 239     /// Returns the type attribute of the st_info member.
 240     unsigned char getType() const { return st_info & 0x0F; }
 241
 242     /// Sets the binding and type of the st_info member.
 243     void setBindingAndType(unsigned char binding, unsigned char type) {
 244         st_info = (binding << 4) + (type & 0x0F);
 245     }
 246
 247     static const char *
 248     bindingToCString(unsigned char binding);
 249
 250     static const char *
 251     typeToCString(unsigned char type);
 252
 253     static const char *
 254     sectionIndexToCString(elf_half shndx,
 255                           const lldb_private::SectionList *section_list);
 256
 257     /// Parse an ELFSymbol entry from the given DataExtractor starting at
 258     /// position \p offset.  The address size of the DataExtractor determines if
 259     /// a 32 or 64 bit object is to be parsed.
 260     ///
 261     /// @param[in] data
 262     ///    The DataExtractor to read from.  The address size of the extractor
 263     ///    determines if a 32 or 64 bit object should be read.
 264     ///
 265     /// @param[in,out] offset
 266     ///    Pointer to an offset in the data.  On return the offset will be
 267     ///    advanced by the number of bytes read.
 268     ///
 269     /// @return
 270     ///    True if the ELFSymbol was successfully read and false otherwise.
 271     bool
 272     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 273
 274     void
 275     Dump (lldb_private::Stream *s,
 276           uint32_t idx,
 277           const lldb_private::DataExtractor *strtab_data,
 278           const lldb_private::SectionList *section_list);
 279 };
 280
 281 //------------------------------------------------------------------------------
 282 /// @class ELFDynamic
 283 /// @brief Represents an entry in an ELF dynamic table.
 284 struct ELFDynamic
 285 {
 286     elf_sxword d_tag;           ///< Type of dynamic table entry.
 287     union
 288     {
 289         elf_xword d_val;        ///< Integer value of the table entry.
 290         elf_addr  d_ptr;        ///< Pointer value of the table entry.
 291     };
 292
 293     ELFDynamic();
 294
 295     /// Parse an ELFDynamic entry from the given DataExtractor starting at
 296     /// position \p offset.  The address size of the DataExtractor determines if
 297     /// a 32 or 64 bit object is to be parsed.
 298     ///
 299     /// @param[in] data
 300     ///    The DataExtractor to read from.  The address size of the extractor
 301     ///    determines if a 32 or 64 bit object should be read.
 302     ///
 303     /// @param[in,out] offset
 304     ///    Pointer to an offset in the data.  On return the offset will be
 305     ///    advanced by the number of bytes read.
 306     ///
 307     /// @return
 308     ///    True if the ELFDynamic entry was successfully read and false
 309     ///    otherwise.
 310     bool
 311     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 312 };
 313
 314 //------------------------------------------------------------------------------
 315 /// @class ELFRel
 316 /// @brief Represents a relocation entry with an implicit addend.
 317 struct ELFRel
 318 {
 319     elf_addr  r_offset;         ///< Address of reference.
 320     elf_xword r_info;           ///< symbol index and type of relocation.
 321
 322     ELFRel();
 323
 324     /// Parse an ELFRel entry from the given DataExtractor starting at position
 325     /// \p offset.  The address size of the DataExtractor determines if a 32 or
 326     /// 64 bit object is to be parsed.
 327     ///
 328     /// @param[in] data
 329     ///    The DataExtractor to read from.  The address size of the extractor
 330     ///    determines if a 32 or 64 bit object should be read.
 331     ///
 332     /// @param[in,out] offset
 333     ///    Pointer to an offset in the data.  On return the offset will be
 334     ///    advanced by the number of bytes read.
 335     ///
 336     /// @return
 337     ///    True if the ELFRel entry was successfully read and false otherwise.
 338     bool
 339     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 340
 341     /// Returns the type when the given entry represents a 32-bit relocation.
 342     static unsigned
 343     RelocType32(const ELFRel &rel)
 344     {
 345         return rel.r_info & 0x0ff;
 346     }
 347
 348     /// Returns the type when the given entry represents a 64-bit relocation.
 349     static unsigned
 350     RelocType64(const ELFRel &rel)
 351     {
 352         return rel.r_info & 0xffffffff;
 353     }
 354
 355     /// Returns the symbol index when the given entry represents a 32-bit
 356     /// reloction.
 357     static unsigned
 358     RelocSymbol32(const ELFRel &rel)
 359     {
 360         return rel.r_info >> 8;
 361     }
 362
 363     /// Returns the symbol index when the given entry represents a 64-bit
 364     /// reloction.
 365     static unsigned
 366     RelocSymbol64(const ELFRel &rel)
 367     {
 368         return rel.r_info >> 32;
 369     }
 370 };
 371
 372 //------------------------------------------------------------------------------
 373 /// @class ELFRela
 374 /// @brief Represents a relocation entry with an explicit addend.
 375 struct ELFRela
 376 {
 377     elf_addr   r_offset;        ///< Address of reference.
 378     elf_xword  r_info;          ///< Symbol index and type of relocation.
 379     elf_sxword r_addend;        ///< Constant part of expression.
 380
 381     ELFRela();
 382
 383     /// Parse an ELFRela entry from the given DataExtractor starting at position
 384     /// \p offset.  The address size of the DataExtractor determines if a 32 or
 385     /// 64 bit object is to be parsed.
 386     ///
 387     /// @param[in] data
 388     ///    The DataExtractor to read from.  The address size of the extractor
 389     ///    determines if a 32 or 64 bit object should be read.
 390     ///
 391     /// @param[in,out] offset
 392     ///    Pointer to an offset in the data.  On return the offset will be
 393     ///    advanced by the number of bytes read.
 394     ///
 395     /// @return
 396     ///    True if the ELFRela entry was successfully read and false otherwise.
 397     bool
 398     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 399
 400     /// Returns the type when the given entry represents a 32-bit relocation.
 401     static unsigned
 402     RelocType32(const ELFRela &rela)
 403     {
 404         return rela.r_info & 0x0ff;
 405     }
 406
 407     /// Returns the type when the given entry represents a 64-bit relocation.
 408     static unsigned
 409     RelocType64(const ELFRela &rela)
 410     {
 411         return rela.r_info & 0xffffffff;
 412     }
 413
 414     /// Returns the symbol index when the given entry represents a 32-bit
 415     /// reloction.
 416     static unsigned
 417     RelocSymbol32(const ELFRela &rela)
 418     {
 419         return rela.r_info >> 8;
 420     }
 421
 422     /// Returns the symbol index when the given entry represents a 64-bit
 423     /// reloction.
 424     static unsigned
 425     RelocSymbol64(const ELFRela &rela)
 426     {
 427         return rela.r_info >> 32;
 428     }
 429 };
 430
 431 } // End namespace elf.
 432
 433 #endif // #ifndef liblldb_ELFHeader_h_