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 Address 517 ObjectFileELF::GetImageInfoAddress() 518 { 519 if (!ParseDynamicSymbols()) 520 return Address(); 521 522 SectionList *section_list = GetSectionList(); 523 if (!section_list) 524 return Address(); 525 526 // Find the SHT_DYNAMIC (.dynamic) section. 527 SectionSP dynsym_section_sp (section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true)); 528 if (!dynsym_section_sp) 529 return Address(); 530 assert (dynsym_section_sp->GetObjectFile() == this); 531 532 user_id_t dynsym_id = dynsym_section_sp->GetID(); 533 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id); 534 if (!dynsym_hdr) 535 return Address(); 536 537 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) 538 { 539 ELFDynamic &symbol = m_dynamic_symbols[i]; 540 541 if (symbol.d_tag == DT_DEBUG) 542 { 543 // Compute the offset as the number of previous entries plus the 544 // size of d_tag. 545 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 546 return Address(dynsym_section_sp, offset); 547 } 548 } 549 550 return Address(); 551 } 552 553 lldb_private::Address 554 ObjectFileELF::GetEntryPointAddress () 555 { 556 if (m_entry_point_address.IsValid()) 557 return m_entry_point_address; 558 559 if (!ParseHeader() || !IsExecutable()) 560 return m_entry_point_address; 561 562 SectionList *section_list = GetSectionList(); 563 addr_t offset = m_header.e_entry; 564 565 if (!section_list) 566 m_entry_point_address.SetOffset(offset); 567 else 568 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list); 569 return m_entry_point_address; 570 } 571 572 //---------------------------------------------------------------------- 573 // ParseDependentModules 574 //---------------------------------------------------------------------- 575 size_t 576 ObjectFileELF::ParseDependentModules() 577 { 578 if (m_filespec_ap.get()) 579 return m_filespec_ap->GetSize(); 580 581 m_filespec_ap.reset(new FileSpecList()); 582 583 if (!ParseSectionHeaders()) 584 return 0; 585 586 SectionList *section_list = GetSectionList(); 587 if (!section_list) 588 return 0; 589 590 // Find the SHT_DYNAMIC section. 591 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 592 if (!dynsym) 593 return 0; 594 assert (dynsym->GetObjectFile() == this); 595 596 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex (dynsym->GetID()); 597 if (!header) 598 return 0; 599 // sh_link: section header index of string table used by entries in the section. 600 Section *dynstr = section_list->FindSectionByID (header->sh_link + 1).get(); 601 if (!dynstr) 602 return 0; 603 604 DataExtractor dynsym_data; 605 DataExtractor dynstr_data; 606 if (ReadSectionData(dynsym, dynsym_data) && 607 ReadSectionData(dynstr, dynstr_data)) 608 { 609 ELFDynamic symbol; 610 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 611 lldb::offset_t offset = 0; 612 613 // The only type of entries we are concerned with are tagged DT_NEEDED, 614 // yielding the name of a required library. 615 while (offset < section_size) 616 { 617 if (!symbol.Parse(dynsym_data, &offset)) 618 break; 619 620 if (symbol.d_tag != DT_NEEDED) 621 continue; 622 623 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 624 const char *lib_name = dynstr_data.PeekCStr(str_index); 625 m_filespec_ap->Append(FileSpec(lib_name, true)); 626 } 627 } 628 629 return m_filespec_ap->GetSize(); 630 } 631 632 //---------------------------------------------------------------------- 633 // ParseProgramHeaders 634 //---------------------------------------------------------------------- 635 size_t 636 ObjectFileELF::ParseProgramHeaders() 637 { 638 // We have already parsed the program headers 639 if (!m_program_headers.empty()) 640 return m_program_headers.size(); 641 642 // If there are no program headers to read we are done. 643 if (m_header.e_phnum == 0) 644 return 0; 645 646 m_program_headers.resize(m_header.e_phnum); 647 if (m_program_headers.size() != m_header.e_phnum) 648 return 0; 649 650 const size_t ph_size = m_header.e_phnum * m_header.e_phentsize; 651 const elf_off ph_offset = m_header.e_phoff; 652 DataExtractor data; 653 if (GetData (ph_offset, ph_size, data) != ph_size) 654 return 0; 655 656 uint32_t idx; 657 lldb::offset_t offset; 658 for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx) 659 { 660 if (m_program_headers[idx].Parse(data, &offset) == false) 661 break; 662 } 663 664 if (idx < m_program_headers.size()) 665 m_program_headers.resize(idx); 666 667 return m_program_headers.size(); 668 } 669 670 static bool 671 ParseNoteGNUBuildID(DataExtractor &data, lldb_private::UUID &uuid) 672 { 673 // Try to parse the note section (ie .note.gnu.build-id|.notes|.note|...) and get the build id. 674 // BuildID documentation: https://fedoraproject.org/wiki/Releases/FeatureBuildId 675 struct 676 { 677 uint32_t name_len; // Length of note name 678 uint32_t desc_len; // Length of note descriptor 679 uint32_t type; // Type of note (1 is ABI_TAG, 3 is BUILD_ID) 680 } notehdr; 681 lldb::offset_t offset = 0; 682 static const uint32_t g_gnu_build_id = 3; // NT_GNU_BUILD_ID from elf.h 683 684 while (true) 685 { 686 if (data.GetU32 (&offset, ¬ehdr, 3) == NULL) 687 return false; 688 689 notehdr.name_len = llvm::RoundUpToAlignment (notehdr.name_len, 4); 690 notehdr.desc_len = llvm::RoundUpToAlignment (notehdr.desc_len, 4); 691 692 lldb::offset_t offset_next_note = offset + notehdr.name_len + notehdr.desc_len; 693 694 // 16 bytes is UUID|MD5, 20 bytes is SHA1 695 if ((notehdr.type == g_gnu_build_id) && (notehdr.name_len == 4) && 696 (notehdr.desc_len == 16 || notehdr.desc_len == 20)) 697 { 698 char name[4]; 699 if (data.GetU8 (&offset, name, 4) == NULL) 700 return false; 701 if (!strcmp(name, "GNU")) 702 { 703 uint8_t uuidbuf[20]; 704 if (data.GetU8 (&offset, &uuidbuf, notehdr.desc_len) == NULL) 705 return false; 706 uuid.SetBytes (uuidbuf, notehdr.desc_len); 707 return true; 708 } 709 } 710 offset = offset_next_note; 711 } 712 return false; 713 } 714 715 //---------------------------------------------------------------------- 716 // GetSectionHeaderInfo 717 //---------------------------------------------------------------------- 718 size_t 719 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 720 lldb_private::DataExtractor &object_data, 721 const elf::ELFHeader &header, 722 lldb_private::UUID &uuid, 723 std::string &gnu_debuglink_file, 724 uint32_t &gnu_debuglink_crc) 725 { 726 // We have already parsed the section headers 727 if (!section_headers.empty()) 728 return section_headers.size(); 729 730 // If there are no section headers we are done. 731 if (header.e_shnum == 0) 732 return 0; 733 734 section_headers.resize(header.e_shnum); 735 if (section_headers.size() != header.e_shnum) 736 return 0; 737 738 const size_t sh_size = header.e_shnum * header.e_shentsize; 739 const elf_off sh_offset = header.e_shoff; 740 DataExtractor sh_data; 741 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 742 return 0; 743 744 uint32_t idx; 745 lldb::offset_t offset; 746 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 747 { 748 if (section_headers[idx].Parse(sh_data, &offset) == false) 749 break; 750 } 751 if (idx < section_headers.size()) 752 section_headers.resize(idx); 753 754 const unsigned strtab_idx = header.e_shstrndx; 755 if (strtab_idx && strtab_idx < section_headers.size()) 756 { 757 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 758 const size_t byte_size = sheader.sh_size; 759 const Elf64_Off offset = sheader.sh_offset; 760 lldb_private::DataExtractor shstr_data; 761 762 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 763 { 764 for (SectionHeaderCollIter I = section_headers.begin(); 765 I != section_headers.end(); ++I) 766 { 767 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 768 const ELFSectionHeaderInfo &header = *I; 769 const uint64_t section_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 770 ConstString name(shstr_data.PeekCStr(I->sh_name)); 771 772 I->section_name = name; 773 774 if (name == g_sect_name_gnu_debuglink) 775 { 776 DataExtractor data; 777 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 778 { 779 lldb::offset_t gnu_debuglink_offset = 0; 780 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 781 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 782 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 783 } 784 } 785 786 if (header.sh_type == SHT_NOTE && !uuid.IsValid()) 787 { 788 DataExtractor data; 789 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 790 { 791 ParseNoteGNUBuildID (data, uuid); 792 } 793 } 794 } 795 796 return section_headers.size(); 797 } 798 } 799 800 section_headers.clear(); 801 return 0; 802 } 803 804 size_t 805 ObjectFileELF::GetProgramHeaderCount() 806 { 807 return ParseProgramHeaders(); 808 } 809 810 const elf::ELFProgramHeader * 811 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 812 { 813 if (!id || !ParseProgramHeaders()) 814 return NULL; 815 816 if (--id < m_program_headers.size()) 817 return &m_program_headers[id]; 818 819 return NULL; 820 } 821 822 DataExtractor 823 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 824 { 825 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 826 if (segment_header == NULL) 827 return DataExtractor(); 828 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 829 } 830 831 //---------------------------------------------------------------------- 832 // ParseSectionHeaders 833 //---------------------------------------------------------------------- 834 size_t 835 ObjectFileELF::ParseSectionHeaders() 836 { 837 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc); 838 } 839 840 const ObjectFileELF::ELFSectionHeaderInfo * 841 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 842 { 843 if (!id || !ParseSectionHeaders()) 844 return NULL; 845 846 if (--id < m_section_headers.size()) 847 return &m_section_headers[id]; 848 849 return NULL; 850 } 851 852 void 853 ObjectFileELF::CreateSections(SectionList &unified_section_list) 854 { 855 if (!m_sections_ap.get() && ParseSectionHeaders()) 856 { 857 m_sections_ap.reset(new SectionList()); 858 859 for (SectionHeaderCollIter I = m_section_headers.begin(); 860 I != m_section_headers.end(); ++I) 861 { 862 const ELFSectionHeaderInfo &header = *I; 863 864 ConstString& name = I->section_name; 865 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 866 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 867 868 static ConstString g_sect_name_text (".text"); 869 static ConstString g_sect_name_data (".data"); 870 static ConstString g_sect_name_bss (".bss"); 871 static ConstString g_sect_name_tdata (".tdata"); 872 static ConstString g_sect_name_tbss (".tbss"); 873 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 874 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 875 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 876 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 877 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 878 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 879 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 880 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 881 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 882 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 883 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 884 static ConstString g_sect_name_eh_frame (".eh_frame"); 885 886 SectionType sect_type = eSectionTypeOther; 887 888 bool is_thread_specific = false; 889 890 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 891 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 892 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 893 else if (name == g_sect_name_tdata) 894 { 895 sect_type = eSectionTypeData; 896 is_thread_specific = true; 897 } 898 else if (name == g_sect_name_tbss) 899 { 900 sect_type = eSectionTypeZeroFill; 901 is_thread_specific = true; 902 } 903 // .debug_abbrev – Abbreviations used in the .debug_info section 904 // .debug_aranges – Lookup table for mapping addresses to compilation units 905 // .debug_frame – Call frame information 906 // .debug_info – The core DWARF information section 907 // .debug_line – Line number information 908 // .debug_loc – Location lists used in DW_AT_location attributes 909 // .debug_macinfo – Macro information 910 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 911 // .debug_pubtypes – Lookup table for mapping type names to compilation units 912 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 913 // .debug_str – String table used in .debug_info 914 // MISSING? .debug-index http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 915 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 916 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 917 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 918 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 919 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 920 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 921 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 922 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 923 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 924 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 925 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 926 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 927 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 928 929 switch (header.sh_type) 930 { 931 case SHT_SYMTAB: 932 assert (sect_type == eSectionTypeOther); 933 sect_type = eSectionTypeELFSymbolTable; 934 break; 935 case SHT_DYNSYM: 936 assert (sect_type == eSectionTypeOther); 937 sect_type = eSectionTypeELFDynamicSymbols; 938 break; 939 case SHT_RELA: 940 case SHT_REL: 941 assert (sect_type == eSectionTypeOther); 942 sect_type = eSectionTypeELFRelocationEntries; 943 break; 944 case SHT_DYNAMIC: 945 assert (sect_type == eSectionTypeOther); 946 sect_type = eSectionTypeELFDynamicLinkInfo; 947 break; 948 } 949 950 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 951 this, // ObjectFile to which this section belongs and should read section data from. 952 SectionIndex(I), // Section ID. 953 name, // Section name. 954 sect_type, // Section type. 955 header.sh_addr, // VM address. 956 vm_size, // VM size in bytes of this section. 957 header.sh_offset, // Offset of this section in the file. 958 file_size, // Size of the section as found in the file. 959 header.sh_flags)); // Flags for this section. 960 961 if (is_thread_specific) 962 section_sp->SetIsThreadSpecific (is_thread_specific); 963 m_sections_ap->AddSection(section_sp); 964 } 965 } 966 967 if (m_sections_ap.get()) 968 { 969 if (GetType() == eTypeDebugInfo) 970 { 971 static const SectionType g_sections[] = 972 { 973 eSectionTypeDWARFDebugAranges, 974 eSectionTypeDWARFDebugInfo, 975 eSectionTypeDWARFDebugAbbrev, 976 eSectionTypeDWARFDebugFrame, 977 eSectionTypeDWARFDebugLine, 978 eSectionTypeDWARFDebugStr, 979 eSectionTypeDWARFDebugLoc, 980 eSectionTypeDWARFDebugMacInfo, 981 eSectionTypeDWARFDebugPubNames, 982 eSectionTypeDWARFDebugPubTypes, 983 eSectionTypeDWARFDebugRanges, 984 eSectionTypeELFSymbolTable, 985 }; 986 SectionList *elf_section_list = m_sections_ap.get(); 987 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 988 { 989 SectionType section_type = g_sections[idx]; 990 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 991 if (section_sp) 992 { 993 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 994 if (module_section_sp) 995 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 996 else 997 unified_section_list.AddSection (section_sp); 998 } 999 } 1000 } 1001 else 1002 { 1003 unified_section_list = *m_sections_ap; 1004 } 1005 } 1006 } 1007 1008 // private 1009 unsigned 1010 ObjectFileELF::ParseSymbols (Symtab *symtab, 1011 user_id_t start_id, 1012 SectionList *section_list, 1013 const size_t num_symbols, 1014 const DataExtractor &symtab_data, 1015 const DataExtractor &strtab_data) 1016 { 1017 ELFSymbol symbol; 1018 lldb::offset_t offset = 0; 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 section 1132 // list. This can happen if we're parsing the debug file and it has no .text section, for example. 1133 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1134 { 1135 ModuleSP module_sp(GetModule()); 1136 if (module_sp) 1137 { 1138 SectionList *module_section_list = module_sp->GetSectionList(); 1139 if (module_section_list && module_section_list != section_list) 1140 { 1141 const ConstString §_name = symbol_section_sp->GetName(); 1142 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1143 if (section_sp && section_sp->GetFileSize()) 1144 { 1145 symbol_section_sp = section_sp; 1146 } 1147 } 1148 } 1149 } 1150 1151 uint64_t symbol_value = symbol.st_value; 1152 if (symbol_section_sp) 1153 symbol_value -= symbol_section_sp->GetFileAddress(); 1154 bool is_global = symbol.getBinding() == STB_GLOBAL; 1155 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1156 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1157 Symbol dc_symbol( 1158 i + start_id, // ID is the original symbol table index. 1159 symbol_name, // Symbol name. 1160 is_mangled, // Is the symbol name mangled? 1161 symbol_type, // Type of this symbol 1162 is_global, // Is this globally visible? 1163 false, // Is this symbol debug info? 1164 false, // Is this symbol a trampoline? 1165 false, // Is this symbol artificial? 1166 symbol_section_sp, // Section in which this symbol is defined or null. 1167 symbol_value, // Offset in section or symbol value. 1168 symbol.st_size, // Size in bytes of this symbol. 1169 true, // Size is valid 1170 flags); // Symbol flags. 1171 symtab->AddSymbol(dc_symbol); 1172 } 1173 1174 return i; 1175 } 1176 1177 unsigned 1178 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 1179 { 1180 if (symtab->GetObjectFile() != this) 1181 { 1182 // If the symbol table section is owned by a different object file, have it do the 1183 // parsing. 1184 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 1185 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 1186 } 1187 1188 // Get section list for this object file. 1189 SectionList *section_list = m_sections_ap.get(); 1190 if (!section_list) 1191 return 0; 1192 1193 user_id_t symtab_id = symtab->GetID(); 1194 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 1195 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1196 symtab_hdr->sh_type == SHT_DYNSYM); 1197 1198 // sh_link: section header index of associated string table. 1199 // Section ID's are ones based. 1200 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1201 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1202 1203 unsigned num_symbols = 0; 1204 if (symtab && strtab) 1205 { 1206 assert (symtab->GetObjectFile() == this); 1207 assert (strtab->GetObjectFile() == this); 1208 1209 DataExtractor symtab_data; 1210 DataExtractor strtab_data; 1211 if (ReadSectionData(symtab, symtab_data) && 1212 ReadSectionData(strtab, strtab_data)) 1213 { 1214 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 1215 1216 num_symbols = ParseSymbols(symbol_table, start_id, 1217 section_list, num_symbols, 1218 symtab_data, strtab_data); 1219 } 1220 } 1221 1222 return num_symbols; 1223 } 1224 1225 size_t 1226 ObjectFileELF::ParseDynamicSymbols() 1227 { 1228 if (m_dynamic_symbols.size()) 1229 return m_dynamic_symbols.size(); 1230 1231 SectionList *section_list = GetSectionList(); 1232 if (!section_list) 1233 return 0; 1234 1235 // Find the SHT_DYNAMIC section. 1236 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1237 if (!dynsym) 1238 return 0; 1239 assert (dynsym->GetObjectFile() == this); 1240 1241 ELFDynamic symbol; 1242 DataExtractor dynsym_data; 1243 if (ReadSectionData(dynsym, dynsym_data)) 1244 { 1245 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1246 lldb::offset_t cursor = 0; 1247 1248 while (cursor < section_size) 1249 { 1250 if (!symbol.Parse(dynsym_data, &cursor)) 1251 break; 1252 1253 m_dynamic_symbols.push_back(symbol); 1254 } 1255 } 1256 1257 return m_dynamic_symbols.size(); 1258 } 1259 1260 const ELFDynamic * 1261 ObjectFileELF::FindDynamicSymbol(unsigned tag) 1262 { 1263 if (!ParseDynamicSymbols()) 1264 return NULL; 1265 1266 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1267 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1268 for ( ; I != E; ++I) 1269 { 1270 ELFDynamic *symbol = &*I; 1271 1272 if (symbol->d_tag == tag) 1273 return symbol; 1274 } 1275 1276 return NULL; 1277 } 1278 1279 unsigned 1280 ObjectFileELF::PLTRelocationType() 1281 { 1282 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1283 1284 if (symbol) 1285 return symbol->d_val; 1286 1287 return 0; 1288 } 1289 1290 static unsigned 1291 ParsePLTRelocations(Symtab *symbol_table, 1292 user_id_t start_id, 1293 unsigned rel_type, 1294 const ELFHeader *hdr, 1295 const ELFSectionHeader *rel_hdr, 1296 const ELFSectionHeader *plt_hdr, 1297 const ELFSectionHeader *sym_hdr, 1298 const lldb::SectionSP &plt_section_sp, 1299 DataExtractor &rel_data, 1300 DataExtractor &symtab_data, 1301 DataExtractor &strtab_data) 1302 { 1303 ELFRelocation rel(rel_type); 1304 ELFSymbol symbol; 1305 lldb::offset_t offset = 0; 1306 const elf_xword plt_entsize = plt_hdr->sh_entsize; 1307 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1308 1309 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1310 reloc_info_fn reloc_type; 1311 reloc_info_fn reloc_symbol; 1312 1313 if (hdr->Is32Bit()) 1314 { 1315 reloc_type = ELFRelocation::RelocType32; 1316 reloc_symbol = ELFRelocation::RelocSymbol32; 1317 } 1318 else 1319 { 1320 reloc_type = ELFRelocation::RelocType64; 1321 reloc_symbol = ELFRelocation::RelocSymbol64; 1322 } 1323 1324 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1325 unsigned i; 1326 for (i = 0; i < num_relocations; ++i) 1327 { 1328 if (rel.Parse(rel_data, &offset) == false) 1329 break; 1330 1331 if (reloc_type(rel) != slot_type) 1332 continue; 1333 1334 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1335 uint64_t plt_index = (i + 1) * plt_entsize; 1336 1337 if (!symbol.Parse(symtab_data, &symbol_offset)) 1338 break; 1339 1340 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1341 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1342 1343 Symbol jump_symbol( 1344 i + start_id, // Symbol table index 1345 symbol_name, // symbol name. 1346 is_mangled, // is the symbol name mangled? 1347 eSymbolTypeTrampoline, // Type of this symbol 1348 false, // Is this globally visible? 1349 false, // Is this symbol debug info? 1350 true, // Is this symbol a trampoline? 1351 true, // Is this symbol artificial? 1352 plt_section_sp, // Section in which this symbol is defined or null. 1353 plt_index, // Offset in section or symbol value. 1354 plt_entsize, // Size in bytes of this symbol. 1355 true, // Size is valid 1356 0); // Symbol flags. 1357 1358 symbol_table->AddSymbol(jump_symbol); 1359 } 1360 1361 return i; 1362 } 1363 1364 unsigned 1365 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 1366 user_id_t start_id, 1367 const ELFSectionHeaderInfo *rel_hdr, 1368 user_id_t rel_id) 1369 { 1370 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 1371 1372 // The link field points to the associated symbol table. The info field 1373 // points to the section holding the plt. 1374 user_id_t symtab_id = rel_hdr->sh_link; 1375 user_id_t plt_id = rel_hdr->sh_info; 1376 1377 if (!symtab_id || !plt_id) 1378 return 0; 1379 1380 // Section ID's are ones based; 1381 symtab_id++; 1382 plt_id++; 1383 1384 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 1385 if (!plt_hdr) 1386 return 0; 1387 1388 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 1389 if (!sym_hdr) 1390 return 0; 1391 1392 SectionList *section_list = m_sections_ap.get(); 1393 if (!section_list) 1394 return 0; 1395 1396 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 1397 if (!rel_section) 1398 return 0; 1399 1400 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 1401 if (!plt_section_sp) 1402 return 0; 1403 1404 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1405 if (!symtab) 1406 return 0; 1407 1408 // sh_link points to associated string table. 1409 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 1410 if (!strtab) 1411 return 0; 1412 1413 DataExtractor rel_data; 1414 if (!ReadSectionData(rel_section, rel_data)) 1415 return 0; 1416 1417 DataExtractor symtab_data; 1418 if (!ReadSectionData(symtab, symtab_data)) 1419 return 0; 1420 1421 DataExtractor strtab_data; 1422 if (!ReadSectionData(strtab, strtab_data)) 1423 return 0; 1424 1425 unsigned rel_type = PLTRelocationType(); 1426 if (!rel_type) 1427 return 0; 1428 1429 return ParsePLTRelocations (symbol_table, 1430 start_id, 1431 rel_type, 1432 &m_header, 1433 rel_hdr, 1434 plt_hdr, 1435 sym_hdr, 1436 plt_section_sp, 1437 rel_data, 1438 symtab_data, 1439 strtab_data); 1440 } 1441 1442 Symtab * 1443 ObjectFileELF::GetSymtab() 1444 { 1445 ModuleSP module_sp(GetModule()); 1446 if (!module_sp) 1447 return NULL; 1448 1449 // We always want to use the main object file so we (hopefully) only have one cached copy 1450 // of our symtab, dynamic sections, etc. 1451 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 1452 if (module_obj_file && module_obj_file != this) 1453 return module_obj_file->GetSymtab(); 1454 1455 if (m_symtab_ap.get() == NULL) 1456 { 1457 SectionList *section_list = GetSectionList(); 1458 if (!section_list) 1459 return NULL; 1460 1461 uint64_t symbol_id = 0; 1462 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 1463 1464 m_symtab_ap.reset(new Symtab(this)); 1465 1466 // Sharable objects and dynamic executables usually have 2 distinct symbol 1467 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 1468 // version of the symtab that only contains global symbols. The information found 1469 // in the dynsym is therefore also found in the symtab, while the reverse is not 1470 // necessarily true. 1471 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 1472 if (!symtab) 1473 { 1474 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 1475 // then use the dynsym section which should always be there. 1476 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 1477 } 1478 if (symtab) 1479 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 1480 1481 // Synthesize trampoline symbols to help navigate the PLT. 1482 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 1483 if (symbol) 1484 { 1485 addr_t addr = symbol->d_ptr; 1486 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 1487 if (reloc_section) 1488 { 1489 user_id_t reloc_id = reloc_section->GetID(); 1490 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 1491 assert(reloc_header); 1492 1493 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 1494 } 1495 } 1496 } 1497 return m_symtab_ap.get(); 1498 } 1499 1500 bool 1501 ObjectFileELF::IsStripped () 1502 { 1503 // TODO: determine this for ELF 1504 return false; 1505 } 1506 1507 //===----------------------------------------------------------------------===// 1508 // Dump 1509 // 1510 // Dump the specifics of the runtime file container (such as any headers 1511 // segments, sections, etc). 1512 //---------------------------------------------------------------------- 1513 void 1514 ObjectFileELF::Dump(Stream *s) 1515 { 1516 DumpELFHeader(s, m_header); 1517 s->EOL(); 1518 DumpELFProgramHeaders(s); 1519 s->EOL(); 1520 DumpELFSectionHeaders(s); 1521 s->EOL(); 1522 SectionList *section_list = GetSectionList(); 1523 if (section_list) 1524 section_list->Dump(s, NULL, true, UINT32_MAX); 1525 Symtab *symtab = GetSymtab(); 1526 if (symtab) 1527 symtab->Dump(s, NULL, eSortOrderNone); 1528 s->EOL(); 1529 DumpDependentModules(s); 1530 s->EOL(); 1531 } 1532 1533 //---------------------------------------------------------------------- 1534 // DumpELFHeader 1535 // 1536 // Dump the ELF header to the specified output stream 1537 //---------------------------------------------------------------------- 1538 void 1539 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 1540 { 1541 s->PutCString("ELF Header\n"); 1542 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 1543 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 1544 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 1545 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 1546 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 1547 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 1548 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 1549 1550 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 1551 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 1552 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 1553 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 1554 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 1555 1556 s->Printf("e_type = 0x%4.4x ", header.e_type); 1557 DumpELFHeader_e_type(s, header.e_type); 1558 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 1559 s->Printf("e_version = 0x%8.8x\n", header.e_version); 1560 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 1561 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 1562 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 1563 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 1564 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 1565 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 1566 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 1567 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 1568 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 1569 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 1570 } 1571 1572 //---------------------------------------------------------------------- 1573 // DumpELFHeader_e_type 1574 // 1575 // Dump an token value for the ELF header member e_type 1576 //---------------------------------------------------------------------- 1577 void 1578 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 1579 { 1580 switch (e_type) 1581 { 1582 case ET_NONE: *s << "ET_NONE"; break; 1583 case ET_REL: *s << "ET_REL"; break; 1584 case ET_EXEC: *s << "ET_EXEC"; break; 1585 case ET_DYN: *s << "ET_DYN"; break; 1586 case ET_CORE: *s << "ET_CORE"; break; 1587 default: 1588 break; 1589 } 1590 } 1591 1592 //---------------------------------------------------------------------- 1593 // DumpELFHeader_e_ident_EI_DATA 1594 // 1595 // Dump an token value for the ELF header member e_ident[EI_DATA] 1596 //---------------------------------------------------------------------- 1597 void 1598 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 1599 { 1600 switch (ei_data) 1601 { 1602 case ELFDATANONE: *s << "ELFDATANONE"; break; 1603 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 1604 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 1605 default: 1606 break; 1607 } 1608 } 1609 1610 1611 //---------------------------------------------------------------------- 1612 // DumpELFProgramHeader 1613 // 1614 // Dump a single ELF program header to the specified output stream 1615 //---------------------------------------------------------------------- 1616 void 1617 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 1618 { 1619 DumpELFProgramHeader_p_type(s, ph.p_type); 1620 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 1621 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 1622 1623 DumpELFProgramHeader_p_flags(s, ph.p_flags); 1624 s->Printf(") %8.8" PRIx64, ph.p_align); 1625 } 1626 1627 //---------------------------------------------------------------------- 1628 // DumpELFProgramHeader_p_type 1629 // 1630 // Dump an token value for the ELF program header member p_type which 1631 // describes the type of the program header 1632 // ---------------------------------------------------------------------- 1633 void 1634 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 1635 { 1636 const int kStrWidth = 15; 1637 switch (p_type) 1638 { 1639 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 1640 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 1641 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 1642 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 1643 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 1644 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 1645 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 1646 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 1647 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 1648 default: 1649 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 1650 break; 1651 } 1652 } 1653 1654 1655 //---------------------------------------------------------------------- 1656 // DumpELFProgramHeader_p_flags 1657 // 1658 // Dump an token value for the ELF program header member p_flags 1659 //---------------------------------------------------------------------- 1660 void 1661 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 1662 { 1663 *s << ((p_flags & PF_X) ? "PF_X" : " ") 1664 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 1665 << ((p_flags & PF_W) ? "PF_W" : " ") 1666 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 1667 << ((p_flags & PF_R) ? "PF_R" : " "); 1668 } 1669 1670 //---------------------------------------------------------------------- 1671 // DumpELFProgramHeaders 1672 // 1673 // Dump all of the ELF program header to the specified output stream 1674 //---------------------------------------------------------------------- 1675 void 1676 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 1677 { 1678 if (ParseProgramHeaders()) 1679 { 1680 s->PutCString("Program Headers\n"); 1681 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 1682 "p_filesz p_memsz p_flags p_align\n"); 1683 s->PutCString("==== --------------- -------- -------- -------- " 1684 "-------- -------- ------------------------- --------\n"); 1685 1686 uint32_t idx = 0; 1687 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 1688 I != m_program_headers.end(); ++I, ++idx) 1689 { 1690 s->Printf("[%2u] ", idx); 1691 ObjectFileELF::DumpELFProgramHeader(s, *I); 1692 s->EOL(); 1693 } 1694 } 1695 } 1696 1697 //---------------------------------------------------------------------- 1698 // DumpELFSectionHeader 1699 // 1700 // Dump a single ELF section header to the specified output stream 1701 //---------------------------------------------------------------------- 1702 void 1703 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 1704 { 1705 s->Printf("%8.8x ", sh.sh_name); 1706 DumpELFSectionHeader_sh_type(s, sh.sh_type); 1707 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 1708 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 1709 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 1710 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 1711 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 1712 } 1713 1714 //---------------------------------------------------------------------- 1715 // DumpELFSectionHeader_sh_type 1716 // 1717 // Dump an token value for the ELF section header member sh_type which 1718 // describes the type of the section 1719 //---------------------------------------------------------------------- 1720 void 1721 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 1722 { 1723 const int kStrWidth = 12; 1724 switch (sh_type) 1725 { 1726 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 1727 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 1728 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 1729 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 1730 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 1731 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 1732 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 1733 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 1734 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 1735 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 1736 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 1737 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 1738 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 1739 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 1740 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 1741 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 1742 default: 1743 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 1744 break; 1745 } 1746 } 1747 1748 //---------------------------------------------------------------------- 1749 // DumpELFSectionHeader_sh_flags 1750 // 1751 // Dump an token value for the ELF section header member sh_flags 1752 //---------------------------------------------------------------------- 1753 void 1754 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 1755 { 1756 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 1757 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 1758 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 1759 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 1760 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 1761 } 1762 1763 //---------------------------------------------------------------------- 1764 // DumpELFSectionHeaders 1765 // 1766 // Dump all of the ELF section header to the specified output stream 1767 //---------------------------------------------------------------------- 1768 void 1769 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 1770 { 1771 if (!ParseSectionHeaders()) 1772 return; 1773 1774 s->PutCString("Section Headers\n"); 1775 s->PutCString("IDX name type flags " 1776 "addr offset size link info addralgn " 1777 "entsize Name\n"); 1778 s->PutCString("==== -------- ------------ -------------------------------- " 1779 "-------- -------- -------- -------- -------- -------- " 1780 "-------- ====================\n"); 1781 1782 uint32_t idx = 0; 1783 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 1784 I != m_section_headers.end(); ++I, ++idx) 1785 { 1786 s->Printf("[%2u] ", idx); 1787 ObjectFileELF::DumpELFSectionHeader(s, *I); 1788 const char* section_name = I->section_name.AsCString(""); 1789 if (section_name) 1790 *s << ' ' << section_name << "\n"; 1791 } 1792 } 1793 1794 void 1795 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 1796 { 1797 size_t num_modules = ParseDependentModules(); 1798 1799 if (num_modules > 0) 1800 { 1801 s->PutCString("Dependent Modules:\n"); 1802 for (unsigned i = 0; i < num_modules; ++i) 1803 { 1804 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 1805 s->Printf(" %s\n", spec.GetFilename().GetCString()); 1806 } 1807 } 1808 } 1809 1810 bool 1811 ObjectFileELF::GetArchitecture (ArchSpec &arch) 1812 { 1813 if (!ParseHeader()) 1814 return false; 1815 1816 arch.SetArchitecture (eArchTypeELF, m_header.e_machine, LLDB_INVALID_CPUTYPE); 1817 arch.GetTriple().setOSName (Host::GetOSString().GetCString()); 1818 arch.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1819 return true; 1820 } 1821 1822 ObjectFile::Type 1823 ObjectFileELF::CalculateType() 1824 { 1825 switch (m_header.e_type) 1826 { 1827 case llvm::ELF::ET_NONE: 1828 // 0 - No file type 1829 return eTypeUnknown; 1830 1831 case llvm::ELF::ET_REL: 1832 // 1 - Relocatable file 1833 return eTypeObjectFile; 1834 1835 case llvm::ELF::ET_EXEC: 1836 // 2 - Executable file 1837 return eTypeExecutable; 1838 1839 case llvm::ELF::ET_DYN: 1840 // 3 - Shared object file 1841 return eTypeSharedLibrary; 1842 1843 case ET_CORE: 1844 // 4 - Core file 1845 return eTypeCoreFile; 1846 1847 default: 1848 break; 1849 } 1850 return eTypeUnknown; 1851 } 1852 1853 ObjectFile::Strata 1854 ObjectFileELF::CalculateStrata() 1855 { 1856 switch (m_header.e_type) 1857 { 1858 case llvm::ELF::ET_NONE: 1859 // 0 - No file type 1860 return eStrataUnknown; 1861 1862 case llvm::ELF::ET_REL: 1863 // 1 - Relocatable file 1864 return eStrataUnknown; 1865 1866 case llvm::ELF::ET_EXEC: 1867 // 2 - Executable file 1868 // TODO: is there any way to detect that an executable is a kernel 1869 // related executable by inspecting the program headers, section 1870 // headers, symbols, or any other flag bits??? 1871 return eStrataUser; 1872 1873 case llvm::ELF::ET_DYN: 1874 // 3 - Shared object file 1875 // TODO: is there any way to detect that an shared library is a kernel 1876 // related executable by inspecting the program headers, section 1877 // headers, symbols, or any other flag bits??? 1878 return eStrataUnknown; 1879 1880 case ET_CORE: 1881 // 4 - Core file 1882 // TODO: is there any way to detect that an core file is a kernel 1883 // related executable by inspecting the program headers, section 1884 // headers, symbols, or any other flag bits??? 1885 return eStrataUnknown; 1886 1887 default: 1888 break; 1889 } 1890 return eStrataUnknown; 1891 } 1892 1893