lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

   1 //===-- ObjectFileELF.h --------------------------------------- -*- 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 LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H
  10 #define LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H
  11
  12 #include <cstdint>
  13
  14 #include <optional>
  15 #include <vector>
  16
  17 #include "lldb/Symbol/ObjectFile.h"
  18 #include "lldb/Utility/ArchSpec.h"
  19 #include "lldb/Utility/FileSpec.h"
  20 #include "lldb/Utility/UUID.h"
  21 #include "lldb/lldb-private.h"
  22
  23 #include "ELFHeader.h"
  24
  25 struct ELFNote {
  26   elf::elf_word n_namesz = 0;
  27   elf::elf_word n_descsz = 0;
  28   elf::elf_word n_type = 0;
  29
  30   std::string n_name;
  31
  32   ELFNote() = default;
  33
  34   /// Parse an ELFNote entry from the given DataExtractor starting at position
  35   /// \p offset.
  36   ///
  37   /// \param[in] data
  38   ///    The DataExtractor to read from.
  39   ///
  40   /// \param[in,out] offset
  41   ///    Pointer to an offset in the data.  On return the offset will be
  42   ///    advanced by the number of bytes read.
  43   ///
  44   /// \return
  45   ///    True if the ELFRel entry was successfully read and false otherwise.
  46   bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
  47
  48   size_t GetByteSize() const {
  49     return 12 + llvm::alignTo(n_namesz, 4) + llvm::alignTo(n_descsz, 4);
  50   }
  51 };
  52
  53 /// \class ObjectFileELF
  54 /// Generic ELF object file reader.
  55 ///
  56 /// This class provides a generic ELF (32/64 bit) reader plugin implementing
  57 /// the ObjectFile protocol.
  58 class ObjectFileELF : public lldb_private::ObjectFile {
  59 public:
  60   // Static Functions
  61   static void Initialize();
  62
  63   static void Terminate();
  64
  65   static llvm::StringRef GetPluginNameStatic() { return "elf"; }
  66
  67   static llvm::StringRef GetPluginDescriptionStatic() {
  68     return "ELF object file reader.";
  69   }
  70
  71   static lldb_private::ObjectFile *
  72   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
  73                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
  74                  lldb::offset_t file_offset, lldb::offset_t length);
  75
  76   static lldb_private::ObjectFile *CreateMemoryInstance(
  77       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
  78       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
  79
  80   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
  81                                         lldb::DataBufferSP &data_sp,
  82                                         lldb::offset_t data_offset,
  83                                         lldb::offset_t file_offset,
  84                                         lldb::offset_t length,
  85                                         lldb_private::ModuleSpecList &specs);
  86
  87   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,
  88                               lldb::addr_t length);
  89
  90   // PluginInterface protocol
  91   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
  92
  93   // LLVM RTTI support
  94   static char ID;
  95   bool isA(const void *ClassID) const override {
  96     return ClassID == &ID || ObjectFile::isA(ClassID);
  97   }
  98   static bool classof(const ObjectFile *obj) { return obj->isA(&ID); }
  99
 100   // ObjectFile Protocol.
 101   bool ParseHeader() override;
 102
 103   bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value,
 104                       bool value_is_offset) override;
 105
 106   lldb::ByteOrder GetByteOrder() const override;
 107
 108   bool IsExecutable() const override;
 109
 110   uint32_t GetAddressByteSize() const override;
 111
 112   lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 113
 114   void ParseSymtab(lldb_private::Symtab &symtab) override;
 115
 116   bool IsStripped() override;
 117
 118   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 119
 120   void Dump(lldb_private::Stream *s) override;
 121
 122   lldb_private::ArchSpec GetArchitecture() override;
 123
 124   lldb_private::UUID GetUUID() override;
 125
 126   /// Return the contents of the .gnu_debuglink section, if the object file
 127   /// contains it.
 128   std::optional<lldb_private::FileSpec> GetDebugLink();
 129
 130   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 131
 132   lldb_private::Address
 133   GetImageInfoAddress(lldb_private::Target *target) override;
 134
 135   lldb_private::Address GetEntryPointAddress() override;
 136
 137   lldb_private::Address GetBaseAddress() 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   llvm::ArrayRef<elf::ELFProgramHeader> ProgramHeaders();
 151   lldb_private::DataExtractor GetSegmentData(const elf::ELFProgramHeader &H);
 152
 153   llvm::StringRef
 154   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
 155
 156   void RelocateSection(lldb_private::Section *section) override;
 157
 158 protected:
 159
 160   std::vector<LoadableData>
 161   GetLoadableData(lldb_private::Target &target) override;
 162
 163   static lldb::WritableDataBufferSP
 164   MapFileDataWritable(const lldb_private::FileSpec &file, uint64_t Size,
 165                       uint64_t Offset);
 166
 167 private:
 168   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
 169                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
 170                 lldb::offset_t offset, lldb::offset_t length);
 171
 172   ObjectFileELF(const lldb::ModuleSP &module_sp,
 173                 lldb::DataBufferSP header_data_sp,
 174                 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 175
 176   typedef std::vector<elf::ELFProgramHeader> ProgramHeaderColl;
 177
 178   struct ELFSectionHeaderInfo : public elf::ELFSectionHeader {
 179     lldb_private::ConstString section_name;
 180   };
 181
 182   typedef std::vector<ELFSectionHeaderInfo> SectionHeaderColl;
 183   typedef SectionHeaderColl::iterator SectionHeaderCollIter;
 184   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
 185
 186   typedef std::vector<elf::ELFDynamic> DynamicSymbolColl;
 187   typedef DynamicSymbolColl::iterator DynamicSymbolCollIter;
 188   typedef DynamicSymbolColl::const_iterator DynamicSymbolCollConstIter;
 189
 190   typedef std::map<lldb::addr_t, lldb_private::AddressClass>
 191       FileAddressToAddressClassMap;
 192
 193   /// Version of this reader common to all plugins based on this class.
 194   static const uint32_t m_plugin_version = 1;
 195   static const uint32_t g_core_uuid_magic;
 196
 197   /// ELF file header.
 198   elf::ELFHeader m_header;
 199
 200   /// ELF build ID.
 201   lldb_private::UUID m_uuid;
 202
 203   /// ELF .gnu_debuglink file and crc data if available.
 204   std::string m_gnu_debuglink_file;
 205   uint32_t m_gnu_debuglink_crc = 0;
 206
 207   /// Collection of program headers.
 208   ProgramHeaderColl m_program_headers;
 209
 210   /// Collection of section headers.
 211   SectionHeaderColl m_section_headers;
 212
 213   /// Collection of symbols from the dynamic table.
 214   DynamicSymbolColl m_dynamic_symbols;
 215
 216   /// Object file parsed from .gnu_debugdata section (\sa
 217   /// GetGnuDebugDataObjectFile())
 218   std::shared_ptr<ObjectFileELF> m_gnu_debug_data_object_file;
 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_up;
 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 the index of the given section header.
 234   size_t SectionIndex(const SectionHeaderCollIter &I);
 235
 236   /// Returns the 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 true iff the headers have been successfully parsed.
 252   bool 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   lldb::SectionType GetSectionType(const ELFSectionHeaderInfo &H) const;
 260
 261   static void ParseARMAttributes(lldb_private::DataExtractor &data,
 262                                  uint64_t length,
 263                                  lldb_private::ArchSpec &arch_spec);
 264
 265   /// Parses the elf section headers and returns the uuid, debug link name,
 266   /// crc, archspec.
 267   static size_t GetSectionHeaderInfo(SectionHeaderColl &section_headers,
 268                                      lldb_private::DataExtractor &object_data,
 269                                      const elf::ELFHeader &header,
 270                                      lldb_private::UUID &uuid,
 271                                      std::string &gnu_debuglink_file,
 272                                      uint32_t &gnu_debuglink_crc,
 273                                      lldb_private::ArchSpec &arch_spec);
 274
 275   /// Scans the dynamic section and locates all dependent modules (shared
 276   /// libraries) populating m_filespec_up.  This method will compute the
 277   /// dependent module list only once.  Returns the number of dependent
 278   /// modules parsed.
 279   size_t ParseDependentModules();
 280
 281   /// Parses the dynamic symbol table and populates m_dynamic_symbols.  The
 282   /// vector retains the order as found in the object file.  Returns the
 283   /// number of dynamic symbols parsed.
 284   size_t ParseDynamicSymbols();
 285
 286   /// Populates the symbol table with all non-dynamic linker symbols.  This
 287   /// method will parse the symbols only once.  Returns the number of symbols
 288   /// parsed.
 289   unsigned ParseSymbolTable(lldb_private::Symtab *symbol_table,
 290                             lldb::user_id_t start_id,
 291                             lldb_private::Section *symtab);
 292
 293   /// Helper routine for ParseSymbolTable().
 294   unsigned ParseSymbols(lldb_private::Symtab *symbol_table,
 295                         lldb::user_id_t start_id,
 296                         lldb_private::SectionList *section_list,
 297                         const size_t num_symbols,
 298                         const lldb_private::DataExtractor &symtab_data,
 299                         const lldb_private::DataExtractor &strtab_data);
 300
 301   /// Scans the relocation entries and adds a set of artificial symbols to the
 302   /// given symbol table for each PLT slot.  Returns the number of symbols
 303   /// added.
 304   unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
 305                                   lldb::user_id_t start_id,
 306                                   const ELFSectionHeaderInfo *rela_hdr,
 307                                   lldb::user_id_t section_id);
 308
 309   void ParseUnwindSymbols(lldb_private::Symtab *symbol_table,
 310                           lldb_private::DWARFCallFrameInfo *eh_frame);
 311
 312   /// Relocates debug sections
 313   unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr,
 314                                  lldb::user_id_t rel_id,
 315                                  lldb_private::Symtab *thetab);
 316
 317   unsigned ApplyRelocations(lldb_private::Symtab *symtab,
 318                             const elf::ELFHeader *hdr,
 319                             const elf::ELFSectionHeader *rel_hdr,
 320                             const elf::ELFSectionHeader *symtab_hdr,
 321                             const elf::ELFSectionHeader *debug_hdr,
 322                             lldb_private::DataExtractor &rel_data,
 323                             lldb_private::DataExtractor &symtab_data,
 324                             lldb_private::DataExtractor &debug_data,
 325                             lldb_private::Section *rel_section);
 326
 327   /// Loads the section name string table into m_shstr_data.  Returns the
 328   /// number of bytes constituting the table.
 329   size_t GetSectionHeaderStringTable();
 330
 331   /// Utility method for looking up a section given its name.  Returns the
 332   /// index of the corresponding section or zero if no section with the given
 333   /// name can be found (note that section indices are always 1 based, and so
 334   /// section index 0 is never valid).
 335   lldb::user_id_t GetSectionIndexByName(const char *name);
 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   /// Takes the .gnu_debugdata and returns the decompressed object file that is
 395   /// stored within that section.
 396   ///
 397   /// \returns either the decompressed object file stored within the
 398   /// .gnu_debugdata section or \c nullptr if an error occured or if there's no
 399   /// section with that name.
 400   std::shared_ptr<ObjectFileELF> GetGnuDebugDataObjectFile();
 401 };
 402
 403 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H