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 §ion_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_ 393