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 GetByteSizeELFNote48 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 GetPluginNameStatic()65 static llvm::StringRef GetPluginNameStatic() { return "elf"; } 66 GetPluginDescriptionStatic()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 GetPluginName()91 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); } 92 93 // LLVM RTTI support 94 static char ID; isA(const void * ClassID)95 bool isA(const void *ClassID) const override { 96 return ClassID == &ID || ObjectFile::isA(ClassID); 97 } classof(const ObjectFile * obj)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 §ion_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 /// An ordered map of file address to address class. Used on architectures 191 /// like Arm where there is an alternative ISA mode like Thumb. The container 192 /// is ordered so that it can be binary searched. 193 typedef std::map<lldb::addr_t, lldb_private::AddressClass> 194 FileAddressToAddressClassMap; 195 196 /// Version of this reader common to all plugins based on this class. 197 static const uint32_t m_plugin_version = 1; 198 static const uint32_t g_core_uuid_magic; 199 200 /// ELF file header. 201 elf::ELFHeader m_header; 202 203 /// ELF build ID. 204 lldb_private::UUID m_uuid; 205 206 /// ELF .gnu_debuglink file and crc data if available. 207 std::string m_gnu_debuglink_file; 208 uint32_t m_gnu_debuglink_crc = 0; 209 210 /// Collection of program headers. 211 ProgramHeaderColl m_program_headers; 212 213 /// Collection of section headers. 214 SectionHeaderColl m_section_headers; 215 216 /// Collection of symbols from the dynamic table. 217 DynamicSymbolColl m_dynamic_symbols; 218 219 /// Object file parsed from .gnu_debugdata section (\sa 220 /// GetGnuDebugDataObjectFile()) 221 std::shared_ptr<ObjectFileELF> m_gnu_debug_data_object_file; 222 223 /// List of file specifications corresponding to the modules (shared 224 /// libraries) on which this object file depends. 225 mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_up; 226 227 /// Cached value of the entry point for this module. 228 lldb_private::Address m_entry_point_address; 229 230 /// The architecture detected from parsing elf file contents. 231 lldb_private::ArchSpec m_arch_spec; 232 233 /// The address class for each symbol in the elf file 234 FileAddressToAddressClassMap m_address_class_map; 235 236 /// Returns the index of the given section header. 237 size_t SectionIndex(const SectionHeaderCollIter &I); 238 239 /// Returns the index of the given section header. 240 size_t SectionIndex(const SectionHeaderCollConstIter &I) const; 241 242 // Parses the ELF program headers. 243 static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers, 244 lldb_private::DataExtractor &object_data, 245 const elf::ELFHeader &header); 246 247 // Finds PT_NOTE segments and calculates their crc sum. 248 static uint32_t 249 CalculateELFNotesSegmentsCRC32(const ProgramHeaderColl &program_headers, 250 lldb_private::DataExtractor &data); 251 252 /// Parses all section headers present in this object file and populates 253 /// m_program_headers. This method will compute the header list only once. 254 /// Returns true iff the headers have been successfully parsed. 255 bool ParseProgramHeaders(); 256 257 /// Parses all section headers present in this object file and populates 258 /// m_section_headers. This method will compute the header list only once. 259 /// Returns the number of headers parsed. 260 size_t ParseSectionHeaders(); 261 262 lldb::SectionType GetSectionType(const ELFSectionHeaderInfo &H) const; 263 264 static void ParseARMAttributes(lldb_private::DataExtractor &data, 265 uint64_t length, 266 lldb_private::ArchSpec &arch_spec); 267 268 /// Parses the elf section headers and returns the uuid, debug link name, 269 /// crc, archspec. 270 static size_t GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 271 lldb_private::DataExtractor &object_data, 272 const elf::ELFHeader &header, 273 lldb_private::UUID &uuid, 274 std::string &gnu_debuglink_file, 275 uint32_t &gnu_debuglink_crc, 276 lldb_private::ArchSpec &arch_spec); 277 278 /// Scans the dynamic section and locates all dependent modules (shared 279 /// libraries) populating m_filespec_up. This method will compute the 280 /// dependent module list only once. Returns the number of dependent 281 /// modules parsed. 282 size_t ParseDependentModules(); 283 284 /// Parses the dynamic symbol table and populates m_dynamic_symbols. The 285 /// vector retains the order as found in the object file. Returns the 286 /// number of dynamic symbols parsed. 287 size_t ParseDynamicSymbols(); 288 289 /// Populates the symbol table with all non-dynamic linker symbols. This 290 /// method will parse the symbols only once. Returns the number of symbols 291 /// parsed and a map of address types (used by targets like Arm that have 292 /// an alternative ISA mode like Thumb). 293 std::pair<unsigned, FileAddressToAddressClassMap> 294 ParseSymbolTable(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, 295 lldb_private::Section *symtab); 296 297 /// Helper routine for ParseSymbolTable(). 298 std::pair<unsigned, FileAddressToAddressClassMap> 299 ParseSymbols(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, 300 lldb_private::SectionList *section_list, 301 const size_t num_symbols, 302 const lldb_private::DataExtractor &symtab_data, 303 const lldb_private::DataExtractor &strtab_data); 304 305 /// Scans the relocation entries and adds a set of artificial symbols to the 306 /// given symbol table for each PLT slot. Returns the number of symbols 307 /// added. 308 unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table, 309 lldb::user_id_t start_id, 310 const ELFSectionHeaderInfo *rela_hdr, 311 lldb::user_id_t section_id); 312 313 void ParseUnwindSymbols(lldb_private::Symtab *symbol_table, 314 lldb_private::DWARFCallFrameInfo *eh_frame); 315 316 /// Relocates debug sections 317 unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr, 318 lldb::user_id_t rel_id, 319 lldb_private::Symtab *thetab); 320 321 unsigned ApplyRelocations(lldb_private::Symtab *symtab, 322 const elf::ELFHeader *hdr, 323 const elf::ELFSectionHeader *rel_hdr, 324 const elf::ELFSectionHeader *symtab_hdr, 325 const elf::ELFSectionHeader *debug_hdr, 326 lldb_private::DataExtractor &rel_data, 327 lldb_private::DataExtractor &symtab_data, 328 lldb_private::DataExtractor &debug_data, 329 lldb_private::Section *rel_section); 330 331 /// Loads the section name string table into m_shstr_data. Returns the 332 /// number of bytes constituting the table. 333 size_t GetSectionHeaderStringTable(); 334 335 /// Utility method for looking up a section given its name. Returns the 336 /// index of the corresponding section or zero if no section with the given 337 /// name can be found (note that section indices are always 1 based, and so 338 /// section index 0 is never valid). 339 lldb::user_id_t GetSectionIndexByName(const char *name); 340 341 /// Returns the section header with the given id or NULL. 342 const ELFSectionHeaderInfo *GetSectionHeaderByIndex(lldb::user_id_t id); 343 344 /// \name ELF header dump routines 345 //@{ 346 static void DumpELFHeader(lldb_private::Stream *s, 347 const elf::ELFHeader &header); 348 349 static void DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s, 350 unsigned char ei_data); 351 352 static void DumpELFHeader_e_type(lldb_private::Stream *s, 353 elf::elf_half e_type); 354 //@} 355 356 /// \name ELF program header dump routines 357 //@{ 358 void DumpELFProgramHeaders(lldb_private::Stream *s); 359 360 static void DumpELFProgramHeader(lldb_private::Stream *s, 361 const elf::ELFProgramHeader &ph); 362 363 static void DumpELFProgramHeader_p_type(lldb_private::Stream *s, 364 elf::elf_word p_type); 365 366 static void DumpELFProgramHeader_p_flags(lldb_private::Stream *s, 367 elf::elf_word p_flags); 368 //@} 369 370 /// \name ELF section header dump routines 371 //@{ 372 void DumpELFSectionHeaders(lldb_private::Stream *s); 373 374 static void DumpELFSectionHeader(lldb_private::Stream *s, 375 const ELFSectionHeaderInfo &sh); 376 377 static void DumpELFSectionHeader_sh_type(lldb_private::Stream *s, 378 elf::elf_word sh_type); 379 380 static void DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, 381 elf::elf_xword sh_flags); 382 //@} 383 384 /// ELF dependent module dump routine. 385 void DumpDependentModules(lldb_private::Stream *s); 386 387 const elf::ELFDynamic *FindDynamicSymbol(unsigned tag); 388 389 unsigned PLTRelocationType(); 390 391 static lldb_private::Status 392 RefineModuleDetailsFromNote(lldb_private::DataExtractor &data, 393 lldb_private::ArchSpec &arch_spec, 394 lldb_private::UUID &uuid); 395 396 bool AnySegmentHasPhysicalAddress(); 397 398 /// Takes the .gnu_debugdata and returns the decompressed object file that is 399 /// stored within that section. 400 /// 401 /// \returns either the decompressed object file stored within the 402 /// .gnu_debugdata section or \c nullptr if an error occured or if there's no 403 /// section with that name. 404 std::shared_ptr<ObjectFileELF> GetGnuDebugDataObjectFile(); 405 }; 406 407 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H 408