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