source/Plugins/ObjectFile/ELF/ObjectFileELF.h

   1 //===-- ObjectFileELF.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 #ifndef liblldb_ObjectFileELF_h_
  11 #define liblldb_ObjectFileELF_h_
  12
  13 // C Includes
  14 #include <stdint.h>
  15
  16 // C++ Includes
  17 #include <functional>
  18 #include <vector>
  19
  20 // Other libraries and framework includes
  21 // Project includes
  22 #include "lldb/Core/ArchSpec.h"
  23 #include "lldb/Core/UUID.h"
  24 #include "lldb/Host/FileSpec.h"
  25 #include "lldb/Symbol/ObjectFile.h"
  26 #include "lldb/lldb-private.h"
  27
  28 #include "ELFHeader.h"
  29
  30 struct ELFNote {
  31   elf::elf_word n_namesz;
  32   elf::elf_word n_descsz;
  33   elf::elf_word n_type;
  34
  35   std::string n_name;
  36
  37   ELFNote() : n_namesz(0), n_descsz(0), n_type(0) {}
  38
  39   /// Parse an ELFNote entry from the given DataExtractor starting at position
  40   /// \p offset.
  41   ///
  42   /// @param[in] data
  43   ///    The DataExtractor to read from.
  44   ///
  45   /// @param[in,out] offset
  46   ///    Pointer to an offset in the data.  On return the offset will be
  47   ///    advanced by the number of bytes read.
  48   ///
  49   /// @return
  50   ///    True if the ELFRel entry was successfully read and false otherwise.
  51   bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
  52
  53   size_t GetByteSize() const {
  54     return 12 + llvm::alignTo(n_namesz, 4) + llvm::alignTo(n_descsz, 4);
  55   }
  56 };
  57
  58 //------------------------------------------------------------------------------
  59 /// @class ObjectFileELF
  60 /// @brief Generic ELF object file reader.
  61 ///
  62 /// This class provides a generic ELF (32/64 bit) reader plugin implementing the
  63 /// ObjectFile protocol.
  64 class ObjectFileELF : public lldb_private::ObjectFile {
  65 public:
  66   ~ObjectFileELF() override;
  67
  68   //------------------------------------------------------------------
  69   // Static Functions
  70   //------------------------------------------------------------------
  71   static void Initialize();
  72
  73   static void Terminate();
  74
  75   static lldb_private::ConstString GetPluginNameStatic();
  76
  77   static const char *GetPluginDescriptionStatic();
  78
  79   static lldb_private::ObjectFile *
  80   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
  81                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
  82                  lldb::offset_t file_offset, lldb::offset_t length);
  83
  84   static lldb_private::ObjectFile *CreateMemoryInstance(
  85       const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
  86       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
  87
  88   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
  89                                         lldb::DataBufferSP &data_sp,
  90                                         lldb::offset_t data_offset,
  91                                         lldb::offset_t file_offset,
  92                                         lldb::offset_t length,
  93                                         lldb_private::ModuleSpecList &specs);
  94
  95   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,
  96                               lldb::addr_t length);
  97
  98   //------------------------------------------------------------------
  99   // PluginInterface protocol
 100   //------------------------------------------------------------------
 101   lldb_private::ConstString GetPluginName() override;
 102
 103   uint32_t GetPluginVersion() override;
 104
 105   //------------------------------------------------------------------
 106   // ObjectFile Protocol.
 107   //------------------------------------------------------------------
 108   bool ParseHeader() override;
 109
 110   bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value,
 111                       bool value_is_offset) override;
 112
 113   lldb::ByteOrder GetByteOrder() const override;
 114
 115   bool IsExecutable() const override;
 116
 117   uint32_t GetAddressByteSize() const override;
 118
 119   lldb::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 120
 121   lldb_private::Symtab *GetSymtab() override;
 122
 123   bool IsStripped() override;
 124
 125   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 126
 127   void Dump(lldb_private::Stream *s) override;
 128
 129   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 130
 131   bool GetUUID(lldb_private::UUID *uuid) override;
 132
 133   lldb_private::FileSpecList GetDebugSymbolFilePaths() override;
 134
 135   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 136
 137   lldb_private::Address
 138   GetImageInfoAddress(lldb_private::Target *target) override;
 139
 140   lldb_private::Address GetEntryPointAddress() override;
 141
 142   ObjectFile::Type CalculateType() override;
 143
 144   ObjectFile::Strata CalculateStrata() override;
 145
 146   // Returns number of program headers found in the ELF file.
 147   size_t GetProgramHeaderCount();
 148
 149   // Returns the program header with the given index.
 150   const elf::ELFProgramHeader *GetProgramHeaderByIndex(lldb::user_id_t id);
 151
 152   // Returns segment data for the given index.
 153   lldb_private::DataExtractor GetSegmentDataByIndex(lldb::user_id_t id);
 154
 155   std::string
 156   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
 157
 158 private:
 159   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
 160                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
 161                 lldb::offset_t offset, lldb::offset_t length);
 162
 163   ObjectFileELF(const lldb::ModuleSP &module_sp,
 164                 lldb::DataBufferSP &header_data_sp,
 165                 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 166
 167   typedef std::vector<elf::ELFProgramHeader> ProgramHeaderColl;
 168   typedef ProgramHeaderColl::iterator ProgramHeaderCollIter;
 169   typedef ProgramHeaderColl::const_iterator ProgramHeaderCollConstIter;
 170
 171   struct ELFSectionHeaderInfo : public elf::ELFSectionHeader {
 172     lldb_private::ConstString section_name;
 173   };
 174
 175   typedef std::vector<ELFSectionHeaderInfo> SectionHeaderColl;
 176   typedef SectionHeaderColl::iterator SectionHeaderCollIter;
 177   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
 178
 179   typedef std::vector<elf::ELFDynamic> DynamicSymbolColl;
 180   typedef DynamicSymbolColl::iterator DynamicSymbolCollIter;
 181   typedef DynamicSymbolColl::const_iterator DynamicSymbolCollConstIter;
 182
 183   typedef std::map<lldb::addr_t, lldb::AddressClass>
 184       FileAddressToAddressClassMap;
 185   typedef std::function<lldb::offset_t(lldb_private::DataExtractor &,
 186                                        lldb::offset_t, lldb::offset_t)>
 187       SetDataFunction;
 188
 189   /// Version of this reader common to all plugins based on this class.
 190   static const uint32_t m_plugin_version = 1;
 191   static const uint32_t g_core_uuid_magic;
 192
 193   /// ELF file header.
 194   elf::ELFHeader m_header;
 195
 196   /// ELF build ID.
 197   lldb_private::UUID m_uuid;
 198
 199   /// ELF .gnu_debuglink file and crc data if available.
 200   std::string m_gnu_debuglink_file;
 201   uint32_t m_gnu_debuglink_crc;
 202
 203   /// Collection of program headers.
 204   ProgramHeaderColl m_program_headers;
 205
 206   /// Collection of section headers.
 207   SectionHeaderColl m_section_headers;
 208
 209   /// Collection of symbols from the dynamic table.
 210   DynamicSymbolColl m_dynamic_symbols;
 211
 212   /// List of file specifications corresponding to the modules (shared
 213   /// libraries) on which this object file depends.
 214   mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_ap;
 215
 216   /// Cached value of the entry point for this module.
 217   lldb_private::Address m_entry_point_address;
 218
 219   /// The architecture detected from parsing elf file contents.
 220   lldb_private::ArchSpec m_arch_spec;
 221
 222   /// The address class for each symbol in the elf file
 223   FileAddressToAddressClassMap m_address_class_map;
 224
 225   /// Returns a 1 based index of the given section header.
 226   size_t SectionIndex(const SectionHeaderCollIter &I);
 227
 228   /// Returns a 1 based index of the given section header.
 229   size_t SectionIndex(const SectionHeaderCollConstIter &I) const;
 230
 231   // Parses the ELF program headers.
 232   static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
 233                                      const SetDataFunction &set_data,
 234                                      const elf::ELFHeader &header);
 235
 236   // Finds PT_NOTE segments and calculates their crc sum.
 237   static uint32_t
 238   CalculateELFNotesSegmentsCRC32(const ProgramHeaderColl &program_headers,
 239                                  lldb_private::DataExtractor &data);
 240
 241   /// Parses all section headers present in this object file and populates
 242   /// m_program_headers.  This method will compute the header list only once.
 243   /// Returns the number of headers parsed.
 244   size_t ParseProgramHeaders();
 245
 246   /// Parses all section headers present in this object file and populates
 247   /// m_section_headers.  This method will compute the header list only once.
 248   /// Returns the number of headers parsed.
 249   size_t ParseSectionHeaders();
 250
 251   static void ParseARMAttributes(lldb_private::DataExtractor &data,
 252                                  uint64_t length,
 253                                  lldb_private::ArchSpec &arch_spec);
 254
 255   /// Parses the elf section headers and returns the uuid, debug link name, crc,
 256   /// archspec.
 257   static size_t GetSectionHeaderInfo(SectionHeaderColl &section_headers,
 258                                      const SetDataFunction &set_data,
 259                                      const elf::ELFHeader &header,
 260                                      lldb_private::UUID &uuid,
 261                                      std::string &gnu_debuglink_file,
 262                                      uint32_t &gnu_debuglink_crc,
 263                                      lldb_private::ArchSpec &arch_spec);
 264
 265   /// Scans the dynamic section and locates all dependent modules (shared
 266   /// libraries) populating m_filespec_ap.  This method will compute the
 267   /// dependent module list only once.  Returns the number of dependent
 268   /// modules parsed.
 269   size_t ParseDependentModules();
 270
 271   /// Parses the dynamic symbol table and populates m_dynamic_symbols.  The
 272   /// vector retains the order as found in the object file.  Returns the
 273   /// number of dynamic symbols parsed.
 274   size_t ParseDynamicSymbols();
 275
 276   /// Populates m_symtab_ap will all non-dynamic linker symbols.  This method
 277   /// will parse the symbols only once.  Returns the number of symbols parsed.
 278   unsigned ParseSymbolTable(lldb_private::Symtab *symbol_table,
 279                             lldb::user_id_t start_id,
 280                             lldb_private::Section *symtab);
 281
 282   /// Helper routine for ParseSymbolTable().
 283   unsigned ParseSymbols(lldb_private::Symtab *symbol_table,
 284                         lldb::user_id_t start_id,
 285                         lldb_private::SectionList *section_list,
 286                         const size_t num_symbols,
 287                         const lldb_private::DataExtractor &symtab_data,
 288                         const lldb_private::DataExtractor &strtab_data);
 289
 290   /// Scans the relocation entries and adds a set of artificial symbols to the
 291   /// given symbol table for each PLT slot.  Returns the number of symbols
 292   /// added.
 293   unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
 294                                   lldb::user_id_t start_id,
 295                                   const ELFSectionHeaderInfo *rela_hdr,
 296                                   lldb::user_id_t section_id);
 297
 298   void ParseUnwindSymbols(lldb_private::Symtab *symbol_table,
 299                           lldb_private::DWARFCallFrameInfo *eh_frame);
 300
 301   /// Relocates debug sections
 302   unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr,
 303                                  lldb::user_id_t rel_id);
 304
 305   unsigned RelocateSection(lldb_private::Symtab *symtab,
 306                            const elf::ELFHeader *hdr,
 307                            const elf::ELFSectionHeader *rel_hdr,
 308                            const elf::ELFSectionHeader *symtab_hdr,
 309                            const elf::ELFSectionHeader *debug_hdr,
 310                            lldb_private::DataExtractor &rel_data,
 311                            lldb_private::DataExtractor &symtab_data,
 312                            lldb_private::DataExtractor &debug_data,
 313                            lldb_private::Section *rel_section);
 314
 315   /// Loads the section name string table into m_shstr_data.  Returns the
 316   /// number of bytes constituting the table.
 317   size_t GetSectionHeaderStringTable();
 318
 319   /// Utility method for looking up a section given its name.  Returns the
 320   /// index of the corresponding section or zero if no section with the given
 321   /// name can be found (note that section indices are always 1 based, and so
 322   /// section index 0 is never valid).
 323   lldb::user_id_t GetSectionIndexByName(const char *name);
 324
 325   // Returns the ID of the first section that has the given type.
 326   lldb::user_id_t GetSectionIndexByType(unsigned type);
 327
 328   /// Returns the section header with the given id or NULL.
 329   const ELFSectionHeaderInfo *GetSectionHeaderByIndex(lldb::user_id_t id);
 330
 331   /// @name  ELF header dump routines
 332   //@{
 333   static void DumpELFHeader(lldb_private::Stream *s,
 334                             const elf::ELFHeader &header);
 335
 336   static void DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s,
 337                                             unsigned char ei_data);
 338
 339   static void DumpELFHeader_e_type(lldb_private::Stream *s,
 340                                    elf::elf_half e_type);
 341   //@}
 342
 343   /// @name ELF program header dump routines
 344   //@{
 345   void DumpELFProgramHeaders(lldb_private::Stream *s);
 346
 347   static void DumpELFProgramHeader(lldb_private::Stream *s,
 348                                    const elf::ELFProgramHeader &ph);
 349
 350   static void DumpELFProgramHeader_p_type(lldb_private::Stream *s,
 351                                           elf::elf_word p_type);
 352
 353   static void DumpELFProgramHeader_p_flags(lldb_private::Stream *s,
 354                                            elf::elf_word p_flags);
 355   //@}
 356
 357   /// @name ELF section header dump routines
 358   //@{
 359   void DumpELFSectionHeaders(lldb_private::Stream *s);
 360
 361   static void DumpELFSectionHeader(lldb_private::Stream *s,
 362                                    const ELFSectionHeaderInfo &sh);
 363
 364   static void DumpELFSectionHeader_sh_type(lldb_private::Stream *s,
 365                                            elf::elf_word sh_type);
 366
 367   static void DumpELFSectionHeader_sh_flags(lldb_private::Stream *s,
 368                                             elf::elf_xword sh_flags);
 369   //@}
 370
 371   /// ELF dependent module dump routine.
 372   void DumpDependentModules(lldb_private::Stream *s);
 373
 374   const elf::ELFDynamic *FindDynamicSymbol(unsigned tag);
 375
 376   unsigned PLTRelocationType();
 377
 378   static lldb_private::Error
 379   RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
 380                               lldb_private::ArchSpec &arch_spec,
 381                               lldb_private::UUID &uuid);
 382
 383   static lldb::offset_t SetData(const lldb_private::DataExtractor &src,
 384                                 lldb_private::DataExtractor &dst,
 385                                 lldb::offset_t offset, lldb::offset_t length);
 386
 387   lldb::offset_t SetDataWithReadMemoryFallback(lldb_private::DataExtractor &dst,
 388                                                lldb::offset_t offset,
 389                                                lldb::offset_t length);
 390 };
 391
 392 #endif // liblldb_ObjectFileELF_h_