1 //===-- ObjectFileELF.cpp ------------------------------------- -*- 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 #include "ObjectFileELF.h" 11 12 #include <cassert> 13 #include <algorithm> 14 15 #include "lldb/Core/ArchSpec.h" 16 #include "lldb/Core/DataBuffer.h" 17 #include "lldb/Core/Error.h" 18 #include "lldb/Core/FileSpecList.h" 19 #include "lldb/Core/Module.h" 20 #include "lldb/Core/ModuleSpec.h" 21 #include "lldb/Core/PluginManager.h" 22 #include "lldb/Core/Section.h" 23 #include "lldb/Core/Stream.h" 24 #include "lldb/Symbol/SymbolContext.h" 25 #include "lldb/Host/Host.h" 26 27 #include "llvm/ADT/PointerUnion.h" 28 29 #define CASE_AND_STREAM(s, def, width) \ 30 case def: s->Printf("%-*s", width, #def); break; 31 32 using namespace lldb; 33 using namespace lldb_private; 34 using namespace elf; 35 using namespace llvm::ELF; 36 37 namespace { 38 //===----------------------------------------------------------------------===// 39 /// @class ELFRelocation 40 /// @brief Generic wrapper for ELFRel and ELFRela. 41 /// 42 /// This helper class allows us to parse both ELFRel and ELFRela relocation 43 /// entries in a generic manner. 44 class ELFRelocation 45 { 46 public: 47 48 /// Constructs an ELFRelocation entry with a personality as given by @p 49 /// type. 50 /// 51 /// @param type Either DT_REL or DT_RELA. Any other value is invalid. 52 ELFRelocation(unsigned type); 53 54 ~ELFRelocation(); 55 56 bool 57 Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); 58 59 static unsigned 60 RelocType32(const ELFRelocation &rel); 61 62 static unsigned 63 RelocType64(const ELFRelocation &rel); 64 65 static unsigned 66 RelocSymbol32(const ELFRelocation &rel); 67 68 static unsigned 69 RelocSymbol64(const ELFRelocation &rel); 70 71 private: 72 typedef llvm::PointerUnion<ELFRel*, ELFRela*> RelocUnion; 73 74 RelocUnion reloc; 75 }; 76 77 ELFRelocation::ELFRelocation(unsigned type) 78 { 79 if (type == DT_REL) 80 reloc = new ELFRel(); 81 else if (type == DT_RELA) 82 reloc = new ELFRela(); 83 else { 84 assert(false && "unexpected relocation type"); 85 reloc = static_cast<ELFRel*>(NULL); 86 } 87 } 88 89 ELFRelocation::~ELFRelocation() 90 { 91 if (reloc.is<ELFRel*>()) 92 delete reloc.get<ELFRel*>(); 93 else 94 delete reloc.get<ELFRela*>(); 95 } 96 97 bool 98 ELFRelocation::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 99 { 100 if (reloc.is<ELFRel*>()) 101 return reloc.get<ELFRel*>()->Parse(data, offset); 102 else 103 return reloc.get<ELFRela*>()->Parse(data, offset); 104 } 105 106 unsigned 107 ELFRelocation::RelocType32(const ELFRelocation &rel) 108 { 109 if (rel.reloc.is<ELFRel*>()) 110 return ELFRel::RelocType32(*rel.reloc.get<ELFRel*>()); 111 else 112 return ELFRela::RelocType32(*rel.reloc.get<ELFRela*>()); 113 } 114 115 unsigned 116 ELFRelocation::RelocType64(const ELFRelocation &rel) 117 { 118 if (rel.reloc.is<ELFRel*>()) 119 return ELFRel::RelocType64(*rel.reloc.get<ELFRel*>()); 120 else 121 return ELFRela::RelocType64(*rel.reloc.get<ELFRela*>()); 122 } 123 124 unsigned 125 ELFRelocation::RelocSymbol32(const ELFRelocation &rel) 126 { 127 if (rel.reloc.is<ELFRel*>()) 128 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel*>()); 129 else 130 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela*>()); 131 } 132 133 unsigned 134 ELFRelocation::RelocSymbol64(const ELFRelocation &rel) 135 { 136 if (rel.reloc.is<ELFRel*>()) 137 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel*>()); 138 else 139 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela*>()); 140 } 141 142 } // end anonymous namespace 143 144 //------------------------------------------------------------------ 145 // Static methods. 146 //------------------------------------------------------------------ 147 void 148 ObjectFileELF::Initialize() 149 { 150 PluginManager::RegisterPlugin(GetPluginNameStatic(), 151 GetPluginDescriptionStatic(), 152 CreateInstance, 153 CreateMemoryInstance, 154 GetModuleSpecifications); 155 } 156 157 void 158 ObjectFileELF::Terminate() 159 { 160 PluginManager::UnregisterPlugin(CreateInstance); 161 } 162 163 lldb_private::ConstString 164 ObjectFileELF::GetPluginNameStatic() 165 { 166 static ConstString g_name("elf"); 167 return g_name; 168 } 169 170 const char * 171 ObjectFileELF::GetPluginDescriptionStatic() 172 { 173 return "ELF object file reader."; 174 } 175 176 ObjectFile * 177 ObjectFileELF::CreateInstance (const lldb::ModuleSP &module_sp, 178 DataBufferSP &data_sp, 179 lldb::offset_t data_offset, 180 const lldb_private::FileSpec* file, 181 lldb::offset_t file_offset, 182 lldb::offset_t length) 183 { 184 if (!data_sp) 185 { 186 data_sp = file->MemoryMapFileContents(file_offset, length); 187 data_offset = 0; 188 } 189 190 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 191 { 192 const uint8_t *magic = data_sp->GetBytes() + data_offset; 193 if (ELFHeader::MagicBytesMatch(magic)) 194 { 195 // Update the data to contain the entire file if it doesn't already 196 if (data_sp->GetByteSize() < length) { 197 data_sp = file->MemoryMapFileContents(file_offset, length); 198 data_offset = 0; 199 magic = data_sp->GetBytes(); 200 } 201 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 202 if (address_size == 4 || address_size == 8) 203 { 204 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, data_offset, file, file_offset, length)); 205 ArchSpec spec; 206 if (objfile_ap->GetArchitecture(spec) && 207 objfile_ap->SetModulesArchitecture(spec)) 208 return objfile_ap.release(); 209 } 210 } 211 } 212 return NULL; 213 } 214 215 216 ObjectFile* 217 ObjectFileELF::CreateMemoryInstance (const lldb::ModuleSP &module_sp, 218 DataBufferSP& data_sp, 219 const lldb::ProcessSP &process_sp, 220 lldb::addr_t header_addr) 221 { 222 return NULL; 223 } 224 225 bool 226 ObjectFileELF::MagicBytesMatch (DataBufferSP& data_sp, 227 lldb::addr_t data_offset, 228 lldb::addr_t data_length) 229 { 230 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 231 { 232 const uint8_t *magic = data_sp->GetBytes() + data_offset; 233 return ELFHeader::MagicBytesMatch(magic); 234 } 235 return false; 236 } 237 238 /* 239 * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c 240 * 241 * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or 242 * code or tables extracted from it, as desired without restriction. 243 */ 244 static uint32_t 245 calc_gnu_debuglink_crc32(const void *buf, size_t size) 246 { 247 static const uint32_t g_crc32_tab[] = 248 { 249 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 250 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 251 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 252 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 253 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 254 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 255 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 256 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 257 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 258 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 259 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 260 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 261 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 262 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 263 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 264 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 265 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 266 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 267 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 268 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 269 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 270 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 271 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 272 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 273 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 274 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 275 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 276 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 277 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 278 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 279 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 280 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 281 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 282 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 283 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 284 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 285 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 286 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 287 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 288 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 289 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 290 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 291 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 292 }; 293 const uint8_t *p = (const uint8_t *)buf; 294 uint32_t crc; 295 296 crc = ~0U; 297 while (size--) 298 crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); 299 return crc ^ ~0U; 300 } 301 302 size_t 303 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file, 304 lldb::DataBufferSP& data_sp, 305 lldb::offset_t data_offset, 306 lldb::offset_t file_offset, 307 lldb::offset_t length, 308 lldb_private::ModuleSpecList &specs) 309 { 310 const size_t initial_count = specs.GetSize(); 311 312 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) 313 { 314 DataExtractor data; 315 data.SetData(data_sp); 316 elf::ELFHeader header; 317 if (header.Parse(data, &data_offset)) 318 { 319 if (data_sp) 320 { 321 ModuleSpec spec; 322 spec.GetFileSpec() = file; 323 spec.GetArchitecture().SetArchitecture(eArchTypeELF, 324 header.e_machine, 325 LLDB_INVALID_CPUTYPE); 326 if (spec.GetArchitecture().IsValid()) 327 { 328 // We could parse the ABI tag information (in .note, .notes, or .note.ABI-tag) to get the 329 // machine information. However, this info isn't guaranteed to exist or be correct. Details: 330 // http://refspecs.linuxfoundation.org/LSB_1.2.0/gLSB/noteabitag.html 331 // Instead of passing potentially incorrect information down the pipeline, grab 332 // the host information and use it. 333 spec.GetArchitecture().GetTriple().setOSName (Host::GetOSString().GetCString()); 334 spec.GetArchitecture().GetTriple().setVendorName(Host::GetVendorString().GetCString()); 335 336 // Try to get the UUID from the section list. Usually that's at the end, so 337 // map the file in if we don't have it already. 338 size_t section_header_end = header.e_shoff + header.e_shnum * header.e_shentsize; 339 if (section_header_end > data_sp->GetByteSize()) 340 { 341 data_sp = file.MemoryMapFileContents (file_offset, section_header_end); 342 data.SetData(data_sp); 343 } 344 345 uint32_t gnu_debuglink_crc = 0; 346 std::string gnu_debuglink_file; 347 SectionHeaderColl section_headers; 348 lldb_private::UUID &uuid = spec.GetUUID(); 349 GetSectionHeaderInfo(section_headers, data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc); 350 351 if (!uuid.IsValid()) 352 { 353 if (!gnu_debuglink_crc) 354 { 355 // Need to map entire file into memory to calculate the crc. 356 data_sp = file.MemoryMapFileContents (file_offset, SIZE_MAX); 357 data.SetData(data_sp); 358 gnu_debuglink_crc = calc_gnu_debuglink_crc32 (data.GetDataStart(), data.GetByteSize()); 359 } 360 if (gnu_debuglink_crc) 361 { 362 // Use 4 bytes of crc from the .gnu_debuglink section. 363 uint32_t uuidt[4] = { gnu_debuglink_crc, 0, 0, 0 }; 364 uuid.SetBytes (uuidt, sizeof(uuidt)); 365 } 366 } 367 368 specs.Append(spec); 369 } 370 } 371 } 372 } 373 374 return specs.GetSize() - initial_count; 375 } 376 377 //------------------------------------------------------------------ 378 // PluginInterface protocol 379 //------------------------------------------------------------------ 380 lldb_private::ConstString 381 ObjectFileELF::GetPluginName() 382 { 383 return GetPluginNameStatic(); 384 } 385 386 uint32_t 387 ObjectFileELF::GetPluginVersion() 388 { 389 return m_plugin_version; 390 } 391 //------------------------------------------------------------------ 392 // ObjectFile protocol 393 //------------------------------------------------------------------ 394 395 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 396 DataBufferSP& data_sp, 397 lldb::offset_t data_offset, 398 const FileSpec* file, 399 lldb::offset_t file_offset, 400 lldb::offset_t length) : 401 ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset), 402 m_header(), 403 m_program_headers(), 404 m_section_headers(), 405 m_filespec_ap() 406 { 407 if (file) 408 m_file = *file; 409 ::memset(&m_header, 0, sizeof(m_header)); 410 m_gnu_debuglink_crc = 0; 411 m_gnu_debuglink_file.clear(); 412 } 413 414 ObjectFileELF::~ObjectFileELF() 415 { 416 } 417 418 bool 419 ObjectFileELF::IsExecutable() const 420 { 421 return m_header.e_entry != 0; 422 } 423 424 ByteOrder 425 ObjectFileELF::GetByteOrder() const 426 { 427 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB) 428 return eByteOrderBig; 429 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB) 430 return eByteOrderLittle; 431 return eByteOrderInvalid; 432 } 433 434 uint32_t 435 ObjectFileELF::GetAddressByteSize() const 436 { 437 return m_data.GetAddressByteSize(); 438 } 439 440 size_t 441 ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) 442 { 443 return std::distance(m_section_headers.begin(), I) + 1u; 444 } 445 446 size_t 447 ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const 448 { 449 return std::distance(m_section_headers.begin(), I) + 1u; 450 } 451 452 bool 453 ObjectFileELF::ParseHeader() 454 { 455 lldb::offset_t offset = 0; 456 return m_header.Parse(m_data, &offset); 457 } 458 459 bool 460 ObjectFileELF::GetUUID(lldb_private::UUID* uuid) 461 { 462 // Need to parse the section list to get the UUIDs, so make sure that's been done. 463 if (!ParseSectionHeaders()) 464 return false; 465 466 if (m_uuid.IsValid()) 467 { 468 // We have the full build id uuid. 469 *uuid = m_uuid; 470 return true; 471 } 472 else 473 { 474 if (!m_gnu_debuglink_crc) 475 m_gnu_debuglink_crc = calc_gnu_debuglink_crc32 (m_data.GetDataStart(), m_data.GetByteSize()); 476 if (m_gnu_debuglink_crc) 477 { 478 // Use 4 bytes of crc from the .gnu_debuglink section. 479 uint32_t uuidt[4] = { m_gnu_debuglink_crc, 0, 0, 0 }; 480 uuid->SetBytes (uuidt, sizeof(uuidt)); 481 return true; 482 } 483 } 484 485 return false; 486 } 487 488 lldb_private::FileSpecList 489 ObjectFileELF::GetDebugSymbolFilePaths() 490 { 491 FileSpecList file_spec_list; 492 493 if (!m_gnu_debuglink_file.empty()) 494 { 495 FileSpec file_spec (m_gnu_debuglink_file.c_str(), false); 496 file_spec_list.Append (file_spec); 497 } 498 return file_spec_list; 499 } 500 501 uint32_t 502 ObjectFileELF::GetDependentModules(FileSpecList &files) 503 { 504 size_t num_modules = ParseDependentModules(); 505 uint32_t num_specs = 0; 506 507 for (unsigned i = 0; i < num_modules; ++i) 508 { 509 if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i))) 510 num_specs++; 511 } 512 513 return num_specs; 514 } 515 516 user_id_t 517 ObjectFileELF::GetSectionIndexByType(unsigned type) 518 { 519 if (!ParseSectionHeaders()) 520 return 0; 521 522 for (SectionHeaderCollIter sh_pos = m_section_headers.begin(); 523 sh_pos != m_section_headers.end(); ++sh_pos) 524 { 525 if (sh_pos->sh_type == type) 526 return SectionIndex(sh_pos); 527 } 528 529 return 0; 530 } 531 532 Address 533 ObjectFileELF::GetImageInfoAddress() 534 { 535 if (!ParseDynamicSymbols()) 536 return Address(); 537 538 SectionList *section_list = GetSectionList(); 539 if (!section_list) 540 return Address(); 541 542 user_id_t dynsym_id = GetSectionIndexByType(SHT_DYNAMIC); 543 if (!dynsym_id) 544 return Address(); 545 546 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id); 547 if (!dynsym_hdr) 548 return Address(); 549 550 SectionSP dynsym_section_sp (section_list->FindSectionByID(dynsym_id)); 551 if (dynsym_section_sp) 552 { 553 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) 554 { 555 ELFDynamic &symbol = m_dynamic_symbols[i]; 556 557 if (symbol.d_tag == DT_DEBUG) 558 { 559 // Compute the offset as the number of previous entries plus the 560 // size of d_tag. 561 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 562 return Address(dynsym_section_sp, offset); 563 } 564 } 565 } 566 567 return Address(); 568 } 569 570 lldb_private::Address 571 ObjectFileELF::GetEntryPointAddress () 572 { 573 SectionList *sections; 574 addr_t offset; 575 576 if (m_entry_point_address.IsValid()) 577 return m_entry_point_address; 578 579 if (!ParseHeader() || !IsExecutable()) 580 return m_entry_point_address; 581 582 sections = GetSectionList(); 583 offset = m_header.e_entry; 584 585 if (!sections) 586 { 587 m_entry_point_address.SetOffset(offset); 588 return m_entry_point_address; 589 } 590 591 m_entry_point_address.ResolveAddressUsingFileSections(offset, sections); 592 593 return m_entry_point_address; 594 } 595 596 //---------------------------------------------------------------------- 597 // ParseDependentModules 598 //---------------------------------------------------------------------- 599 size_t 600 ObjectFileELF::ParseDependentModules() 601 { 602 if (m_filespec_ap.get()) 603 return m_filespec_ap->GetSize(); 604 605 m_filespec_ap.reset(new FileSpecList()); 606 607 if (!ParseSectionHeaders()) 608 return 0; 609 610 // Locate the dynamic table. 611 user_id_t dynsym_id = 0; 612 user_id_t dynstr_id = 0; 613 for (SectionHeaderCollIter sh_pos = m_section_headers.begin(); 614 sh_pos != m_section_headers.end(); ++sh_pos) 615 { 616 if (sh_pos->sh_type == SHT_DYNAMIC) 617 { 618 dynsym_id = SectionIndex(sh_pos); 619 dynstr_id = sh_pos->sh_link + 1; // Section ID's are 1 based. 620 break; 621 } 622 } 623 624 if (!(dynsym_id && dynstr_id)) 625 return 0; 626 627 SectionList *section_list = GetSectionList(); 628 if (!section_list) 629 return 0; 630 631 // Resolve and load the dynamic table entries and corresponding string 632 // table. 633 Section *dynsym = section_list->FindSectionByID(dynsym_id).get(); 634 Section *dynstr = section_list->FindSectionByID(dynstr_id).get(); 635 if (!(dynsym && dynstr)) 636 return 0; 637 638 DataExtractor dynsym_data; 639 DataExtractor dynstr_data; 640 if (ReadSectionData(dynsym, dynsym_data) && 641 ReadSectionData(dynstr, dynstr_data)) 642 { 643 ELFDynamic symbol; 644 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 645 lldb::offset_t offset = 0; 646 647 // The only type of entries we are concerned with are tagged DT_NEEDED, 648 // yielding the name of a required library. 649 while (offset < section_size) 650 { 651 if (!symbol.Parse(dynsym_data, &offset)) 652 break; 653 654 if (symbol.d_tag != DT_NEEDED) 655 continue; 656 657 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 658 const char *lib_name = dynstr_data.PeekCStr(str_index); 659 m_filespec_ap->Append(FileSpec(lib_name, true)); 660 } 661 } 662 663 return m_filespec_ap->GetSize(); 664 } 665 666 //---------------------------------------------------------------------- 667 // ParseProgramHeaders 668 //---------------------------------------------------------------------- 669 size_t 670 ObjectFileELF::ParseProgramHeaders() 671 { 672 // We have already parsed the program headers 673 if (!m_program_headers.empty()) 674 return m_program_headers.size(); 675 676 // If there are no program headers to read we are done. 677 if (m_header.e_phnum == 0) 678 return 0; 679 680 m_program_headers.resize(m_header.e_phnum); 681 if (m_program_headers.size() != m_header.e_phnum) 682 return 0; 683 684 const size_t ph_size = m_header.e_phnum * m_header.e_phentsize; 685 const elf_off ph_offset = m_header.e_phoff; 686 DataExtractor data; 687 if (GetData (ph_offset, ph_size, data) != ph_size) 688 return 0; 689 690 uint32_t idx; 691 lldb::offset_t offset; 692 for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx) 693 { 694 if (m_program_headers[idx].Parse(data, &offset) == false) 695 break; 696 } 697 698 if (idx < m_program_headers.size()) 699 m_program_headers.resize(idx); 700 701 return m_program_headers.size(); 702 } 703 704 static bool 705 ParseNoteGNUBuildID(DataExtractor &data, lldb_private::UUID &uuid) 706 { 707 // Try to parse the note section (ie .note.gnu.build-id|.notes|.note|...) and get the build id. 708 // BuildID documentation: https://fedoraproject.org/wiki/Releases/FeatureBuildId 709 struct 710 { 711 uint32_t name_len; // Length of note name 712 uint32_t desc_len; // Length of note descriptor 713 uint32_t type; // Type of note (1 is ABI_TAG, 3 is BUILD_ID) 714 } notehdr; 715 lldb::offset_t offset = 0; 716 static const uint32_t g_gnu_build_id = 3; // NT_GNU_BUILD_ID from elf.h 717 718 while (true) 719 { 720 if (data.GetU32 (&offset, ¬ehdr, 3) == NULL) 721 return false; 722 723 notehdr.name_len = llvm::RoundUpToAlignment (notehdr.name_len, 4); 724 notehdr.desc_len = llvm::RoundUpToAlignment (notehdr.desc_len, 4); 725 726 lldb::offset_t offset_next_note = offset + notehdr.name_len + notehdr.desc_len; 727 728 // 16 bytes is UUID|MD5, 20 bytes is SHA1 729 if ((notehdr.type == g_gnu_build_id) && (notehdr.name_len == 4) && 730 (notehdr.desc_len == 16 || notehdr.desc_len == 20)) 731 { 732 char name[4]; 733 if (data.GetU8 (&offset, name, 4) == NULL) 734 return false; 735 if (!strcmp(name, "GNU")) 736 { 737 uint8_t uuidbuf[20]; 738 if (data.GetU8 (&offset, &uuidbuf, notehdr.desc_len) == NULL) 739 return false; 740 uuid.SetBytes (uuidbuf, notehdr.desc_len); 741 return true; 742 } 743 } 744 offset = offset_next_note; 745 } 746 return false; 747 } 748 749 //---------------------------------------------------------------------- 750 // GetSectionHeaderInfo 751 //---------------------------------------------------------------------- 752 size_t 753 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 754 lldb_private::DataExtractor &object_data, 755 const elf::ELFHeader &header, 756 lldb_private::UUID &uuid, 757 std::string &gnu_debuglink_file, 758 uint32_t &gnu_debuglink_crc) 759 { 760 // We have already parsed the section headers 761 if (!section_headers.empty()) 762 return section_headers.size(); 763 764 // If there are no section headers we are done. 765 if (header.e_shnum == 0) 766 return 0; 767 768 section_headers.resize(header.e_shnum); 769 if (section_headers.size() != header.e_shnum) 770 return 0; 771 772 const size_t sh_size = header.e_shnum * header.e_shentsize; 773 const elf_off sh_offset = header.e_shoff; 774 DataExtractor sh_data; 775 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 776 return 0; 777 778 uint32_t idx; 779 lldb::offset_t offset; 780 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 781 { 782 if (section_headers[idx].Parse(sh_data, &offset) == false) 783 break; 784 } 785 if (idx < section_headers.size()) 786 section_headers.resize(idx); 787 788 const unsigned strtab_idx = header.e_shstrndx; 789 if (strtab_idx && strtab_idx < section_headers.size()) 790 { 791 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 792 const size_t byte_size = sheader.sh_size; 793 const Elf64_Off offset = sheader.sh_offset; 794 lldb_private::DataExtractor shstr_data; 795 796 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 797 { 798 for (SectionHeaderCollIter I = section_headers.begin(); 799 I != section_headers.end(); ++I) 800 { 801 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 802 const ELFSectionHeaderInfo &header = *I; 803 const uint64_t section_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 804 ConstString name(shstr_data.PeekCStr(I->sh_name)); 805 806 I->section_name = name; 807 808 if (name == g_sect_name_gnu_debuglink) 809 { 810 DataExtractor data; 811 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 812 { 813 lldb::offset_t gnu_debuglink_offset = 0; 814 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 815 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 816 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 817 } 818 } 819 820 if (header.sh_type == SHT_NOTE && !uuid.IsValid()) 821 { 822 DataExtractor data; 823 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 824 { 825 ParseNoteGNUBuildID (data, uuid); 826 } 827 } 828 } 829 830 return section_headers.size(); 831 } 832 } 833 834 section_headers.clear(); 835 return 0; 836 } 837 838 //---------------------------------------------------------------------- 839 // ParseSectionHeaders 840 //---------------------------------------------------------------------- 841 size_t 842 ObjectFileELF::ParseSectionHeaders() 843 { 844 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc); 845 } 846 847 lldb::user_id_t 848 ObjectFileELF::GetSectionIndexByName(const char *name) 849 { 850 if (!ParseSectionHeaders()) 851 return 0; 852 853 // Search the collection of section headers for one with a matching name. 854 for (SectionHeaderCollIter I = m_section_headers.begin(); 855 I != m_section_headers.end(); ++I) 856 { 857 const char *sectionName = I->section_name.AsCString(); 858 859 if (!sectionName) 860 return 0; 861 862 if (strcmp(name, sectionName) != 0) 863 continue; 864 865 return SectionIndex(I); 866 } 867 868 return 0; 869 } 870 871 const ObjectFileELF::ELFSectionHeaderInfo * 872 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 873 { 874 if (!ParseSectionHeaders() || !id) 875 return NULL; 876 877 if (--id < m_section_headers.size()) 878 return &m_section_headers[id]; 879 880 return NULL; 881 } 882 883 884 SectionList * 885 ObjectFileELF::GetSectionList() 886 { 887 if (m_sections_ap.get()) 888 return m_sections_ap.get(); 889 890 if (ParseSectionHeaders()) 891 { 892 m_sections_ap.reset(new SectionList()); 893 894 for (SectionHeaderCollIter I = m_section_headers.begin(); 895 I != m_section_headers.end(); ++I) 896 { 897 const ELFSectionHeaderInfo &header = *I; 898 899 ConstString& name = I->section_name; 900 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 901 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 902 903 static ConstString g_sect_name_text (".text"); 904 static ConstString g_sect_name_data (".data"); 905 static ConstString g_sect_name_bss (".bss"); 906 static ConstString g_sect_name_tdata (".tdata"); 907 static ConstString g_sect_name_tbss (".tbss"); 908 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 909 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 910 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 911 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 912 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 913 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 914 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 915 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 916 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 917 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 918 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 919 static ConstString g_sect_name_eh_frame (".eh_frame"); 920 921 SectionType sect_type = eSectionTypeOther; 922 923 bool is_thread_specific = false; 924 925 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 926 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 927 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 928 else if (name == g_sect_name_tdata) 929 { 930 sect_type = eSectionTypeData; 931 is_thread_specific = true; 932 } 933 else if (name == g_sect_name_tbss) 934 { 935 sect_type = eSectionTypeZeroFill; 936 is_thread_specific = true; 937 } 938 // .debug_abbrev – Abbreviations used in the .debug_info section 939 // .debug_aranges – Lookup table for mapping addresses to compilation units 940 // .debug_frame – Call frame information 941 // .debug_info – The core DWARF information section 942 // .debug_line – Line number information 943 // .debug_loc – Location lists used in DW_AT_location attributes 944 // .debug_macinfo – Macro information 945 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 946 // .debug_pubtypes – Lookup table for mapping type names to compilation units 947 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 948 // .debug_str – String table used in .debug_info 949 // MISSING? .debug-index http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 950 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 951 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 952 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 953 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 954 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 955 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 956 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 957 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 958 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 959 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 960 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 961 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 962 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 963 964 switch (header.sh_type) 965 { 966 case SHT_SYMTAB: 967 assert (sect_type == eSectionTypeOther); 968 sect_type = eSectionTypeELFSymbolTable; 969 break; 970 case SHT_DYNSYM: 971 assert (sect_type == eSectionTypeOther); 972 sect_type = eSectionTypeELFDynamicSymbols; 973 break; 974 case SHT_RELA: 975 case SHT_REL: 976 assert (sect_type == eSectionTypeOther); 977 sect_type = eSectionTypeELFRelocationEntries; 978 break; 979 case SHT_DYNAMIC: 980 assert (sect_type == eSectionTypeOther); 981 sect_type = eSectionTypeELFDynamicLinkInfo; 982 break; 983 } 984 985 SectionSP section_sp(new Section( 986 GetModule(), // Module to which this section belongs. 987 this, // ObjectFile to which this section belongs and should read section data from. 988 SectionIndex(I), // Section ID. 989 name, // Section name. 990 sect_type, // Section type. 991 header.sh_addr, // VM address. 992 vm_size, // VM size in bytes of this section. 993 header.sh_offset, // Offset of this section in the file. 994 file_size, // Size of the section as found in the file. 995 header.sh_flags)); // Flags for this section. 996 997 if (is_thread_specific) 998 section_sp->SetIsThreadSpecific (is_thread_specific); 999 m_sections_ap->AddSection(section_sp); 1000 } 1001 1002 m_sections_ap->Finalize(); // Now that we're done adding sections, finalize to build fast-lookup caches 1003 } 1004 1005 return m_sections_ap.get(); 1006 } 1007 1008 unsigned 1009 ObjectFileELF::ParseSymbols(Symtab *symtab, 1010 user_id_t start_id, 1011 SectionList *section_list, 1012 const ELFSectionHeaderInfo *symtab_shdr, 1013 const DataExtractor &symtab_data, 1014 const DataExtractor &strtab_data) 1015 { 1016 ELFSymbol symbol; 1017 lldb::offset_t offset = 0; 1018 const size_t num_symbols = symtab_data.GetByteSize() / symtab_shdr->sh_entsize; 1019 1020 static ConstString text_section_name(".text"); 1021 static ConstString init_section_name(".init"); 1022 static ConstString fini_section_name(".fini"); 1023 static ConstString ctors_section_name(".ctors"); 1024 static ConstString dtors_section_name(".dtors"); 1025 1026 static ConstString data_section_name(".data"); 1027 static ConstString rodata_section_name(".rodata"); 1028 static ConstString rodata1_section_name(".rodata1"); 1029 static ConstString data2_section_name(".data1"); 1030 static ConstString bss_section_name(".bss"); 1031 1032 //StreamFile strm(stdout, false); 1033 unsigned i; 1034 for (i = 0; i < num_symbols; ++i) 1035 { 1036 if (symbol.Parse(symtab_data, &offset) == false) 1037 break; 1038 1039 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1040 1041 // No need to add symbols that have no names 1042 if (symbol_name == NULL || symbol_name[0] == '\0') 1043 continue; 1044 1045 //symbol.Dump (&strm, i, &strtab_data, section_list); 1046 1047 SectionSP symbol_section_sp; 1048 SymbolType symbol_type = eSymbolTypeInvalid; 1049 Elf64_Half symbol_idx = symbol.st_shndx; 1050 1051 switch (symbol_idx) 1052 { 1053 case SHN_ABS: 1054 symbol_type = eSymbolTypeAbsolute; 1055 break; 1056 case SHN_UNDEF: 1057 symbol_type = eSymbolTypeUndefined; 1058 break; 1059 default: 1060 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 1061 break; 1062 } 1063 1064 // If a symbol is undefined do not process it further even if it has a STT type 1065 if (symbol_type != eSymbolTypeUndefined) 1066 { 1067 switch (symbol.getType()) 1068 { 1069 default: 1070 case STT_NOTYPE: 1071 // The symbol's type is not specified. 1072 break; 1073 1074 case STT_OBJECT: 1075 // The symbol is associated with a data object, such as a variable, 1076 // an array, etc. 1077 symbol_type = eSymbolTypeData; 1078 break; 1079 1080 case STT_FUNC: 1081 // The symbol is associated with a function or other executable code. 1082 symbol_type = eSymbolTypeCode; 1083 break; 1084 1085 case STT_SECTION: 1086 // The symbol is associated with a section. Symbol table entries of 1087 // this type exist primarily for relocation and normally have 1088 // STB_LOCAL binding. 1089 break; 1090 1091 case STT_FILE: 1092 // Conventionally, the symbol's name gives the name of the source 1093 // file associated with the object file. A file symbol has STB_LOCAL 1094 // binding, its section index is SHN_ABS, and it precedes the other 1095 // STB_LOCAL symbols for the file, if it is present. 1096 symbol_type = eSymbolTypeSourceFile; 1097 break; 1098 1099 case STT_GNU_IFUNC: 1100 // The symbol is associated with an indirect function. The actual 1101 // function will be resolved if it is referenced. 1102 symbol_type = eSymbolTypeResolver; 1103 break; 1104 } 1105 } 1106 1107 if (symbol_type == eSymbolTypeInvalid) 1108 { 1109 if (symbol_section_sp) 1110 { 1111 const ConstString §_name = symbol_section_sp->GetName(); 1112 if (sect_name == text_section_name || 1113 sect_name == init_section_name || 1114 sect_name == fini_section_name || 1115 sect_name == ctors_section_name || 1116 sect_name == dtors_section_name) 1117 { 1118 symbol_type = eSymbolTypeCode; 1119 } 1120 else if (sect_name == data_section_name || 1121 sect_name == data2_section_name || 1122 sect_name == rodata_section_name || 1123 sect_name == rodata1_section_name || 1124 sect_name == bss_section_name) 1125 { 1126 symbol_type = eSymbolTypeData; 1127 } 1128 } 1129 } 1130 1131 // If the symbol section we've found has no data (SHT_NOBITS), then check the module 1132 // for the main object file and use the section there if it has data. This can happen 1133 // if we're parsing the debug file and the it has no .text section, for example. 1134 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1135 { 1136 ModuleSP module_sp(GetModule()); 1137 if (module_sp) 1138 { 1139 ObjectFile *obj_file = module_sp->GetObjectFile(); 1140 // Check if we've got a different object file than ourselves. 1141 if (obj_file && (obj_file != this)) 1142 { 1143 const ConstString §_name = symbol_section_sp->GetName(); 1144 SectionList *obj_file_section_list = obj_file->GetSectionList(); 1145 lldb::SectionSP section_sp (obj_file_section_list->FindSectionByName (sect_name)); 1146 if (section_sp && section_sp->GetFileSize()) 1147 { 1148 symbol_section_sp = section_sp; 1149 } 1150 } 1151 } 1152 } 1153 1154 uint64_t symbol_value = symbol.st_value; 1155 if (symbol_section_sp) 1156 symbol_value -= symbol_section_sp->GetFileAddress(); 1157 bool is_global = symbol.getBinding() == STB_GLOBAL; 1158 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1159 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1160 Symbol dc_symbol( 1161 i + start_id, // ID is the original symbol table index. 1162 symbol_name, // Symbol name. 1163 is_mangled, // Is the symbol name mangled? 1164 symbol_type, // Type of this symbol 1165 is_global, // Is this globally visible? 1166 false, // Is this symbol debug info? 1167 false, // Is this symbol a trampoline? 1168 false, // Is this symbol artificial? 1169 symbol_section_sp, // Section in which this symbol is defined or null. 1170 symbol_value, // Offset in section or symbol value. 1171 symbol.st_size, // Size in bytes of this symbol. 1172 true, // Size is valid 1173 flags); // Symbol flags. 1174 symtab->AddSymbol(dc_symbol); 1175 } 1176 1177 return i; 1178 } 1179 1180 unsigned 1181 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, user_id_t symtab_id) 1182 { 1183 // Parse in the section list if needed. 1184 SectionList *section_list = GetSectionList(); 1185 if (!section_list) 1186 return 0; 1187 1188 const ELFSectionHeaderInfo *symtab_hdr = &m_section_headers[symtab_id - 1]; 1189 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1190 symtab_hdr->sh_type == SHT_DYNSYM); 1191 1192 // Section ID's are ones based. 1193 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1194 1195 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1196 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1197 unsigned num_symbols = 0; 1198 if (symtab && strtab) 1199 { 1200 DataExtractor symtab_data; 1201 DataExtractor strtab_data; 1202 if (ReadSectionData(symtab, symtab_data) && 1203 ReadSectionData(strtab, strtab_data)) 1204 { 1205 num_symbols = ParseSymbols(symbol_table, start_id, 1206 section_list, symtab_hdr, 1207 symtab_data, strtab_data); 1208 } 1209 } 1210 1211 return num_symbols; 1212 } 1213 1214 size_t 1215 ObjectFileELF::ParseDynamicSymbols() 1216 { 1217 if (m_dynamic_symbols.size()) 1218 return m_dynamic_symbols.size(); 1219 1220 user_id_t dyn_id = GetSectionIndexByType(SHT_DYNAMIC); 1221 if (!dyn_id) 1222 return 0; 1223 1224 SectionList *section_list = GetSectionList(); 1225 if (!section_list) 1226 return 0; 1227 1228 Section *dynsym = section_list->FindSectionByID(dyn_id).get(); 1229 if (!dynsym) 1230 return 0; 1231 1232 ELFDynamic symbol; 1233 DataExtractor dynsym_data; 1234 if (ReadSectionData(dynsym, dynsym_data)) 1235 { 1236 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1237 lldb::offset_t cursor = 0; 1238 1239 while (cursor < section_size) 1240 { 1241 if (!symbol.Parse(dynsym_data, &cursor)) 1242 break; 1243 1244 m_dynamic_symbols.push_back(symbol); 1245 } 1246 } 1247 1248 return m_dynamic_symbols.size(); 1249 } 1250 1251 const ELFDynamic * 1252 ObjectFileELF::FindDynamicSymbol(unsigned tag) 1253 { 1254 if (!ParseDynamicSymbols()) 1255 return NULL; 1256 1257 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1258 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1259 for ( ; I != E; ++I) 1260 { 1261 ELFDynamic *symbol = &*I; 1262 1263 if (symbol->d_tag == tag) 1264 return symbol; 1265 } 1266 1267 return NULL; 1268 } 1269 1270 unsigned 1271 ObjectFileELF::PLTRelocationType() 1272 { 1273 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1274 1275 if (symbol) 1276 return symbol->d_val; 1277 1278 return 0; 1279 } 1280 1281 static unsigned 1282 ParsePLTRelocations(Symtab *symbol_table, 1283 user_id_t start_id, 1284 unsigned rel_type, 1285 const ELFHeader *hdr, 1286 const ELFSectionHeader *rel_hdr, 1287 const ELFSectionHeader *plt_hdr, 1288 const ELFSectionHeader *sym_hdr, 1289 const lldb::SectionSP &plt_section_sp, 1290 DataExtractor &rel_data, 1291 DataExtractor &symtab_data, 1292 DataExtractor &strtab_data) 1293 { 1294 ELFRelocation rel(rel_type); 1295 ELFSymbol symbol; 1296 lldb::offset_t offset = 0; 1297 const elf_xword plt_entsize = plt_hdr->sh_entsize; 1298 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1299 1300 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1301 reloc_info_fn reloc_type; 1302 reloc_info_fn reloc_symbol; 1303 1304 if (hdr->Is32Bit()) 1305 { 1306 reloc_type = ELFRelocation::RelocType32; 1307 reloc_symbol = ELFRelocation::RelocSymbol32; 1308 } 1309 else 1310 { 1311 reloc_type = ELFRelocation::RelocType64; 1312 reloc_symbol = ELFRelocation::RelocSymbol64; 1313 } 1314 1315 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1316 unsigned i; 1317 for (i = 0; i < num_relocations; ++i) 1318 { 1319 if (rel.Parse(rel_data, &offset) == false) 1320 break; 1321 1322 if (reloc_type(rel) != slot_type) 1323 continue; 1324 1325 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1326 uint64_t plt_index = (i + 1) * plt_entsize; 1327 1328 if (!symbol.Parse(symtab_data, &symbol_offset)) 1329 break; 1330 1331 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1332 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1333 1334 Symbol jump_symbol( 1335 i + start_id, // Symbol table index 1336 symbol_name, // symbol name. 1337 is_mangled, // is the symbol name mangled? 1338 eSymbolTypeTrampoline, // Type of this symbol 1339 false, // Is this globally visible? 1340 false, // Is this symbol debug info? 1341 true, // Is this symbol a trampoline? 1342 true, // Is this symbol artificial? 1343 plt_section_sp, // Section in which this symbol is defined or null. 1344 plt_index, // Offset in section or symbol value. 1345 plt_entsize, // Size in bytes of this symbol. 1346 true, // Size is valid 1347 0); // Symbol flags. 1348 1349 symbol_table->AddSymbol(jump_symbol); 1350 } 1351 1352 return i; 1353 } 1354 1355 unsigned 1356 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 1357 user_id_t start_id, 1358 const ELFSectionHeaderInfo *rel_hdr, 1359 user_id_t rel_id) 1360 { 1361 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 1362 1363 // The link field points to the associated symbol table. The info field 1364 // points to the section holding the plt. 1365 user_id_t symtab_id = rel_hdr->sh_link; 1366 user_id_t plt_id = rel_hdr->sh_info; 1367 1368 if (!symtab_id || !plt_id) 1369 return 0; 1370 1371 // Section ID's are ones based; 1372 symtab_id++; 1373 plt_id++; 1374 1375 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 1376 if (!plt_hdr) 1377 return 0; 1378 1379 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 1380 if (!sym_hdr) 1381 return 0; 1382 1383 SectionList *section_list = GetSectionList(); 1384 if (!section_list) 1385 return 0; 1386 1387 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 1388 if (!rel_section) 1389 return 0; 1390 1391 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 1392 if (!plt_section_sp) 1393 return 0; 1394 1395 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1396 if (!symtab) 1397 return 0; 1398 1399 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 1400 if (!strtab) 1401 return 0; 1402 1403 DataExtractor rel_data; 1404 if (!ReadSectionData(rel_section, rel_data)) 1405 return 0; 1406 1407 DataExtractor symtab_data; 1408 if (!ReadSectionData(symtab, symtab_data)) 1409 return 0; 1410 1411 DataExtractor strtab_data; 1412 if (!ReadSectionData(strtab, strtab_data)) 1413 return 0; 1414 1415 unsigned rel_type = PLTRelocationType(); 1416 if (!rel_type) 1417 return 0; 1418 1419 return ParsePLTRelocations (symbol_table, 1420 start_id, 1421 rel_type, 1422 &m_header, 1423 rel_hdr, 1424 plt_hdr, 1425 sym_hdr, 1426 plt_section_sp, 1427 rel_data, 1428 symtab_data, 1429 strtab_data); 1430 } 1431 1432 Symtab * 1433 ObjectFileELF::GetSymtab(uint32_t flags) 1434 { 1435 ModuleSP module_sp(GetModule()); 1436 if (module_sp) 1437 { 1438 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 1439 1440 bool from_unified_section_list = !!(flags & eSymtabFromUnifiedSectionList); 1441 SectionList *section_list = from_unified_section_list ? module_sp->GetUnifiedSectionList() : GetSectionList(); 1442 if (!section_list) 1443 return NULL; 1444 1445 // If we're doing the unified section list and it has been modified, then clear our 1446 // cache and reload the symbols. If needed, we could check on only the sections that 1447 // we use to create the symbol table... 1448 std::unique_ptr<lldb_private::Symtab> &symtab_ap = from_unified_section_list ? m_symtab_unified_ap : m_symtab_ap; 1449 if (from_unified_section_list && (m_symtab_unified_revisionid != section_list->GetRevisionID())) 1450 { 1451 symtab_ap.reset(); 1452 m_symtab_unified_revisionid = section_list->GetRevisionID(); 1453 } 1454 else if (symtab_ap.get()) 1455 { 1456 return symtab_ap.get(); 1457 } 1458 1459 Symtab *symbol_table = new Symtab(this); 1460 symtab_ap.reset(symbol_table); 1461 1462 // Sharable objects and dynamic executables usually have 2 distinct symbol 1463 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 1464 // version of the symtab that only contains global symbols. The information found 1465 // in the dynsym is therefore also found in the symtab, while the reverse is not 1466 // necessarily true. 1467 Section *section_sym = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 1468 if (!section_sym) 1469 { 1470 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 1471 // then use the dynsym section which should always be there. 1472 section_sym = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 1473 } 1474 1475 uint64_t symbol_id = 0; 1476 if (section_sym) 1477 { 1478 user_id_t section_id = section_sym->GetID(); 1479 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(section_sym->GetObjectFile()); 1480 1481 symbol_id += obj_file_elf->ParseSymbolTable (symbol_table, symbol_id, section_id); 1482 } 1483 1484 Section *section = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1485 if (section) 1486 { 1487 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(section->GetObjectFile()); 1488 1489 // Synthesize trampoline symbols to help navigate the PLT. 1490 const ELFDynamic *symbol = obj_file_elf->FindDynamicSymbol(DT_JMPREL); 1491 if (symbol) 1492 { 1493 addr_t addr = symbol->d_ptr; 1494 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 1495 if (reloc_section) 1496 { 1497 user_id_t reloc_id = reloc_section->GetID(); 1498 const ELFSectionHeaderInfo *reloc_header = obj_file_elf->GetSectionHeaderByIndex(reloc_id); 1499 assert(reloc_header); 1500 1501 obj_file_elf->ParseTrampolineSymbols(symbol_table, symbol_id, reloc_header, reloc_id); 1502 } 1503 } 1504 } 1505 1506 return symbol_table; 1507 } 1508 return NULL; 1509 } 1510 1511 //===----------------------------------------------------------------------===// 1512 // Dump 1513 // 1514 // Dump the specifics of the runtime file container (such as any headers 1515 // segments, sections, etc). 1516 //---------------------------------------------------------------------- 1517 void 1518 ObjectFileELF::Dump(Stream *s) 1519 { 1520 DumpELFHeader(s, m_header); 1521 s->EOL(); 1522 DumpELFProgramHeaders(s); 1523 s->EOL(); 1524 DumpELFSectionHeaders(s); 1525 s->EOL(); 1526 SectionList *section_list = GetSectionList(); 1527 if (section_list) 1528 section_list->Dump(s, NULL, true, UINT32_MAX); 1529 Symtab *symtab = GetSymtab(); 1530 if (symtab) 1531 symtab->Dump(s, NULL, eSortOrderNone); 1532 s->EOL(); 1533 DumpDependentModules(s); 1534 s->EOL(); 1535 } 1536 1537 //---------------------------------------------------------------------- 1538 // DumpELFHeader 1539 // 1540 // Dump the ELF header to the specified output stream 1541 //---------------------------------------------------------------------- 1542 void 1543 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 1544 { 1545 s->PutCString("ELF Header\n"); 1546 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 1547 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 1548 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 1549 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 1550 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 1551 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 1552 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 1553 1554 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 1555 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 1556 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 1557 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 1558 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 1559 1560 s->Printf("e_type = 0x%4.4x ", header.e_type); 1561 DumpELFHeader_e_type(s, header.e_type); 1562 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 1563 s->Printf("e_version = 0x%8.8x\n", header.e_version); 1564 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 1565 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 1566 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 1567 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 1568 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 1569 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 1570 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 1571 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 1572 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 1573 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 1574 } 1575 1576 //---------------------------------------------------------------------- 1577 // DumpELFHeader_e_type 1578 // 1579 // Dump an token value for the ELF header member e_type 1580 //---------------------------------------------------------------------- 1581 void 1582 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 1583 { 1584 switch (e_type) 1585 { 1586 case ET_NONE: *s << "ET_NONE"; break; 1587 case ET_REL: *s << "ET_REL"; break; 1588 case ET_EXEC: *s << "ET_EXEC"; break; 1589 case ET_DYN: *s << "ET_DYN"; break; 1590 case ET_CORE: *s << "ET_CORE"; break; 1591 default: 1592 break; 1593 } 1594 } 1595 1596 //---------------------------------------------------------------------- 1597 // DumpELFHeader_e_ident_EI_DATA 1598 // 1599 // Dump an token value for the ELF header member e_ident[EI_DATA] 1600 //---------------------------------------------------------------------- 1601 void 1602 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 1603 { 1604 switch (ei_data) 1605 { 1606 case ELFDATANONE: *s << "ELFDATANONE"; break; 1607 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 1608 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 1609 default: 1610 break; 1611 } 1612 } 1613 1614 1615 //---------------------------------------------------------------------- 1616 // DumpELFProgramHeader 1617 // 1618 // Dump a single ELF program header to the specified output stream 1619 //---------------------------------------------------------------------- 1620 void 1621 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 1622 { 1623 DumpELFProgramHeader_p_type(s, ph.p_type); 1624 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 1625 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 1626 1627 DumpELFProgramHeader_p_flags(s, ph.p_flags); 1628 s->Printf(") %8.8" PRIx64, ph.p_align); 1629 } 1630 1631 //---------------------------------------------------------------------- 1632 // DumpELFProgramHeader_p_type 1633 // 1634 // Dump an token value for the ELF program header member p_type which 1635 // describes the type of the program header 1636 // ---------------------------------------------------------------------- 1637 void 1638 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 1639 { 1640 const int kStrWidth = 15; 1641 switch (p_type) 1642 { 1643 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 1644 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 1645 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 1646 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 1647 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 1648 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 1649 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 1650 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 1651 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 1652 default: 1653 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 1654 break; 1655 } 1656 } 1657 1658 1659 //---------------------------------------------------------------------- 1660 // DumpELFProgramHeader_p_flags 1661 // 1662 // Dump an token value for the ELF program header member p_flags 1663 //---------------------------------------------------------------------- 1664 void 1665 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 1666 { 1667 *s << ((p_flags & PF_X) ? "PF_X" : " ") 1668 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 1669 << ((p_flags & PF_W) ? "PF_W" : " ") 1670 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 1671 << ((p_flags & PF_R) ? "PF_R" : " "); 1672 } 1673 1674 //---------------------------------------------------------------------- 1675 // DumpELFProgramHeaders 1676 // 1677 // Dump all of the ELF program header to the specified output stream 1678 //---------------------------------------------------------------------- 1679 void 1680 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 1681 { 1682 if (ParseProgramHeaders()) 1683 { 1684 s->PutCString("Program Headers\n"); 1685 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 1686 "p_filesz p_memsz p_flags p_align\n"); 1687 s->PutCString("==== --------------- -------- -------- -------- " 1688 "-------- -------- ------------------------- --------\n"); 1689 1690 uint32_t idx = 0; 1691 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 1692 I != m_program_headers.end(); ++I, ++idx) 1693 { 1694 s->Printf("[%2u] ", idx); 1695 ObjectFileELF::DumpELFProgramHeader(s, *I); 1696 s->EOL(); 1697 } 1698 } 1699 } 1700 1701 //---------------------------------------------------------------------- 1702 // DumpELFSectionHeader 1703 // 1704 // Dump a single ELF section header to the specified output stream 1705 //---------------------------------------------------------------------- 1706 void 1707 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 1708 { 1709 s->Printf("%8.8x ", sh.sh_name); 1710 DumpELFSectionHeader_sh_type(s, sh.sh_type); 1711 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 1712 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 1713 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 1714 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 1715 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 1716 } 1717 1718 //---------------------------------------------------------------------- 1719 // DumpELFSectionHeader_sh_type 1720 // 1721 // Dump an token value for the ELF section header member sh_type which 1722 // describes the type of the section 1723 //---------------------------------------------------------------------- 1724 void 1725 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 1726 { 1727 const int kStrWidth = 12; 1728 switch (sh_type) 1729 { 1730 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 1731 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 1732 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 1733 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 1734 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 1735 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 1736 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 1737 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 1738 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 1739 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 1740 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 1741 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 1742 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 1743 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 1744 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 1745 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 1746 default: 1747 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 1748 break; 1749 } 1750 } 1751 1752 //---------------------------------------------------------------------- 1753 // DumpELFSectionHeader_sh_flags 1754 // 1755 // Dump an token value for the ELF section header member sh_flags 1756 //---------------------------------------------------------------------- 1757 void 1758 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 1759 { 1760 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 1761 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 1762 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 1763 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 1764 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 1765 } 1766 1767 //---------------------------------------------------------------------- 1768 // DumpELFSectionHeaders 1769 // 1770 // Dump all of the ELF section header to the specified output stream 1771 //---------------------------------------------------------------------- 1772 void 1773 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 1774 { 1775 if (!ParseSectionHeaders()) 1776 return; 1777 1778 s->PutCString("Section Headers\n"); 1779 s->PutCString("IDX name type flags " 1780 "addr offset size link info addralgn " 1781 "entsize Name\n"); 1782 s->PutCString("==== -------- ------------ -------------------------------- " 1783 "-------- -------- -------- -------- -------- -------- " 1784 "-------- ====================\n"); 1785 1786 uint32_t idx = 0; 1787 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 1788 I != m_section_headers.end(); ++I, ++idx) 1789 { 1790 s->Printf("[%2u] ", idx); 1791 ObjectFileELF::DumpELFSectionHeader(s, *I); 1792 const char* section_name = I->section_name.AsCString(""); 1793 if (section_name) 1794 *s << ' ' << section_name << "\n"; 1795 } 1796 } 1797 1798 void 1799 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 1800 { 1801 size_t num_modules = ParseDependentModules(); 1802 1803 if (num_modules > 0) 1804 { 1805 s->PutCString("Dependent Modules:\n"); 1806 for (unsigned i = 0; i < num_modules; ++i) 1807 { 1808 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 1809 s->Printf(" %s\n", spec.GetFilename().GetCString()); 1810 } 1811 } 1812 } 1813 1814 bool 1815 ObjectFileELF::GetArchitecture (ArchSpec &arch) 1816 { 1817 if (!ParseHeader()) 1818 return false; 1819 1820 arch.SetArchitecture (eArchTypeELF, m_header.e_machine, LLDB_INVALID_CPUTYPE); 1821 arch.GetTriple().setOSName (Host::GetOSString().GetCString()); 1822 arch.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1823 return true; 1824 } 1825 1826 ObjectFile::Type 1827 ObjectFileELF::CalculateType() 1828 { 1829 switch (m_header.e_type) 1830 { 1831 case llvm::ELF::ET_NONE: 1832 // 0 - No file type 1833 return eTypeUnknown; 1834 1835 case llvm::ELF::ET_REL: 1836 // 1 - Relocatable file 1837 return eTypeObjectFile; 1838 1839 case llvm::ELF::ET_EXEC: 1840 // 2 - Executable file 1841 return eTypeExecutable; 1842 1843 case llvm::ELF::ET_DYN: 1844 // 3 - Shared object file 1845 return eTypeSharedLibrary; 1846 1847 case ET_CORE: 1848 // 4 - Core file 1849 return eTypeCoreFile; 1850 1851 default: 1852 break; 1853 } 1854 return eTypeUnknown; 1855 } 1856 1857 ObjectFile::Strata 1858 ObjectFileELF::CalculateStrata() 1859 { 1860 switch (m_header.e_type) 1861 { 1862 case llvm::ELF::ET_NONE: 1863 // 0 - No file type 1864 return eStrataUnknown; 1865 1866 case llvm::ELF::ET_REL: 1867 // 1 - Relocatable file 1868 return eStrataUnknown; 1869 1870 case llvm::ELF::ET_EXEC: 1871 // 2 - Executable file 1872 // TODO: is there any way to detect that an executable is a kernel 1873 // related executable by inspecting the program headers, section 1874 // headers, symbols, or any other flag bits??? 1875 return eStrataUser; 1876 1877 case llvm::ELF::ET_DYN: 1878 // 3 - Shared object file 1879 // TODO: is there any way to detect that an shared library is a kernel 1880 // related executable by inspecting the program headers, section 1881 // headers, symbols, or any other flag bits??? 1882 return eStrataUnknown; 1883 1884 case ET_CORE: 1885 // 4 - Core file 1886 // TODO: is there any way to detect that an core file is a kernel 1887 // related executable by inspecting the program headers, section 1888 // headers, symbols, or any other flag bits??? 1889 return eStrataUnknown; 1890 1891 default: 1892 break; 1893 } 1894 return eStrataUnknown; 1895 } 1896 1897