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 32using namespace lldb; 33using namespace lldb_private; 34using namespace elf; 35using namespace llvm::ELF; 36 37namespace { 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. 44class ELFRelocation 45{ 46public: 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 71private: 72 typedef llvm::PointerUnion<ELFRel*, ELFRela*> RelocUnion; 73 74 RelocUnion reloc; 75}; 76 77ELFRelocation::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 89ELFRelocation::~ELFRelocation() 90{ 91 if (reloc.is<ELFRel*>()) 92 delete reloc.get<ELFRel*>(); 93 else 94 delete reloc.get<ELFRela*>(); 95} 96 97bool 98ELFRelocation::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 106unsigned 107ELFRelocation::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 115unsigned 116ELFRelocation::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 124unsigned 125ELFRelocation::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 133unsigned 134ELFRelocation::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//------------------------------------------------------------------ 147void 148ObjectFileELF::Initialize() 149{ 150 PluginManager::RegisterPlugin(GetPluginNameStatic(), 151 GetPluginDescriptionStatic(), 152 CreateInstance, 153 CreateMemoryInstance, 154 GetModuleSpecifications); 155} 156 157void 158ObjectFileELF::Terminate() 159{ 160 PluginManager::UnregisterPlugin(CreateInstance); 161} 162 163lldb_private::ConstString 164ObjectFileELF::GetPluginNameStatic() 165{ 166 static ConstString g_name("elf"); 167 return g_name; 168} 169 170const char * 171ObjectFileELF::GetPluginDescriptionStatic() 172{ 173 return "ELF object file reader."; 174} 175 176ObjectFile * 177ObjectFileELF::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 216ObjectFile* 217ObjectFileELF::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 225bool 226ObjectFileELF::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 */ 244static uint32_t 245calc_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 302size_t 303ObjectFileELF::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//------------------------------------------------------------------ 380lldb_private::ConstString 381ObjectFileELF::GetPluginName() 382{ 383 return GetPluginNameStatic(); 384} 385 386uint32_t 387ObjectFileELF::GetPluginVersion() 388{ 389 return m_plugin_version; 390} 391//------------------------------------------------------------------ 392// ObjectFile protocol 393//------------------------------------------------------------------ 394 395ObjectFileELF::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 414ObjectFileELF::~ObjectFileELF() 415{ 416} 417 418bool 419ObjectFileELF::IsExecutable() const 420{ 421 return m_header.e_entry != 0; 422} 423 424ByteOrder 425ObjectFileELF::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 434uint32_t 435ObjectFileELF::GetAddressByteSize() const 436{ 437 return m_data.GetAddressByteSize(); 438} 439 440size_t 441ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) 442{ 443 return std::distance(m_section_headers.begin(), I) + 1u; 444} 445 446size_t 447ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const 448{ 449 return std::distance(m_section_headers.begin(), I) + 1u; 450} 451 452bool 453ObjectFileELF::ParseHeader() 454{ 455 lldb::offset_t offset = 0; 456 return m_header.Parse(m_data, &offset); 457} 458 459bool 460ObjectFileELF::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 488lldb_private::FileSpecList 489ObjectFileELF::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 501uint32_t 502ObjectFileELF::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 516Address 517ObjectFileELF::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 553lldb_private::Address 554ObjectFileELF::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//---------------------------------------------------------------------- 575size_t 576ObjectFileELF::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//---------------------------------------------------------------------- 635size_t 636ObjectFileELF::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 670static bool 671ParseNoteGNUBuildID(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//---------------------------------------------------------------------- 718size_t 719ObjectFileELF::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 804size_t 805ObjectFileELF::GetProgramHeaderCount() 806{ 807 return ParseProgramHeaders(); 808} 809 810const elf::ELFProgramHeader * 811ObjectFileELF::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 822DataExtractor 823ObjectFileELF::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//---------------------------------------------------------------------- 834size_t 835ObjectFileELF::ParseSectionHeaders() 836{ 837 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc); 838} 839 840const ObjectFileELF::ELFSectionHeaderInfo * 841ObjectFileELF::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 852void 853ObjectFileELF::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? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 915 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 916 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 917 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 918 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 919 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 920 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 921 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 922 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 923 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 924 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 925 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 926 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 927 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 928 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 929 930 switch (header.sh_type) 931 { 932 case SHT_SYMTAB: 933 assert (sect_type == eSectionTypeOther); 934 sect_type = eSectionTypeELFSymbolTable; 935 break; 936 case SHT_DYNSYM: 937 assert (sect_type == eSectionTypeOther); 938 sect_type = eSectionTypeELFDynamicSymbols; 939 break; 940 case SHT_RELA: 941 case SHT_REL: 942 assert (sect_type == eSectionTypeOther); 943 sect_type = eSectionTypeELFRelocationEntries; 944 break; 945 case SHT_DYNAMIC: 946 assert (sect_type == eSectionTypeOther); 947 sect_type = eSectionTypeELFDynamicLinkInfo; 948 break; 949 } 950 951 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 952 this, // ObjectFile to which this section belongs and should read section data from. 953 SectionIndex(I), // Section ID. 954 name, // Section name. 955 sect_type, // Section type. 956 header.sh_addr, // VM address. 957 vm_size, // VM size in bytes of this section. 958 header.sh_offset, // Offset of this section in the file. 959 file_size, // Size of the section as found in the file. 960 header.sh_flags)); // Flags for this section. 961 962 if (is_thread_specific) 963 section_sp->SetIsThreadSpecific (is_thread_specific); 964 m_sections_ap->AddSection(section_sp); 965 } 966 } 967 968 if (m_sections_ap.get()) 969 { 970 if (GetType() == eTypeDebugInfo) 971 { 972 static const SectionType g_sections[] = 973 { 974 eSectionTypeDWARFDebugAranges, 975 eSectionTypeDWARFDebugInfo, 976 eSectionTypeDWARFDebugAbbrev, 977 eSectionTypeDWARFDebugFrame, 978 eSectionTypeDWARFDebugLine, 979 eSectionTypeDWARFDebugStr, 980 eSectionTypeDWARFDebugLoc, 981 eSectionTypeDWARFDebugMacInfo, 982 eSectionTypeDWARFDebugPubNames, 983 eSectionTypeDWARFDebugPubTypes, 984 eSectionTypeDWARFDebugRanges, 985 eSectionTypeELFSymbolTable, 986 }; 987 SectionList *elf_section_list = m_sections_ap.get(); 988 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 989 { 990 SectionType section_type = g_sections[idx]; 991 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 992 if (section_sp) 993 { 994 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 995 if (module_section_sp) 996 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 997 else 998 unified_section_list.AddSection (section_sp); 999 } 1000 } 1001 } 1002 else 1003 { 1004 unified_section_list = *m_sections_ap; 1005 } 1006 } 1007} 1008 1009// private 1010unsigned 1011ObjectFileELF::ParseSymbols (Symtab *symtab, 1012 user_id_t start_id, 1013 SectionList *section_list, 1014 const size_t num_symbols, 1015 const DataExtractor &symtab_data, 1016 const DataExtractor &strtab_data) 1017{ 1018 ELFSymbol symbol; 1019 lldb::offset_t offset = 0; 1020 1021 static ConstString text_section_name(".text"); 1022 static ConstString init_section_name(".init"); 1023 static ConstString fini_section_name(".fini"); 1024 static ConstString ctors_section_name(".ctors"); 1025 static ConstString dtors_section_name(".dtors"); 1026 1027 static ConstString data_section_name(".data"); 1028 static ConstString rodata_section_name(".rodata"); 1029 static ConstString rodata1_section_name(".rodata1"); 1030 static ConstString data2_section_name(".data1"); 1031 static ConstString bss_section_name(".bss"); 1032 1033 //StreamFile strm(stdout, false); 1034 unsigned i; 1035 for (i = 0; i < num_symbols; ++i) 1036 { 1037 if (symbol.Parse(symtab_data, &offset) == false) 1038 break; 1039 1040 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1041 1042 // No need to add symbols that have no names 1043 if (symbol_name == NULL || symbol_name[0] == '\0') 1044 continue; 1045 1046 //symbol.Dump (&strm, i, &strtab_data, section_list); 1047 1048 SectionSP symbol_section_sp; 1049 SymbolType symbol_type = eSymbolTypeInvalid; 1050 Elf64_Half symbol_idx = symbol.st_shndx; 1051 1052 switch (symbol_idx) 1053 { 1054 case SHN_ABS: 1055 symbol_type = eSymbolTypeAbsolute; 1056 break; 1057 case SHN_UNDEF: 1058 symbol_type = eSymbolTypeUndefined; 1059 break; 1060 default: 1061 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 1062 break; 1063 } 1064 1065 // If a symbol is undefined do not process it further even if it has a STT type 1066 if (symbol_type != eSymbolTypeUndefined) 1067 { 1068 switch (symbol.getType()) 1069 { 1070 default: 1071 case STT_NOTYPE: 1072 // The symbol's type is not specified. 1073 break; 1074 1075 case STT_OBJECT: 1076 // The symbol is associated with a data object, such as a variable, 1077 // an array, etc. 1078 symbol_type = eSymbolTypeData; 1079 break; 1080 1081 case STT_FUNC: 1082 // The symbol is associated with a function or other executable code. 1083 symbol_type = eSymbolTypeCode; 1084 break; 1085 1086 case STT_SECTION: 1087 // The symbol is associated with a section. Symbol table entries of 1088 // this type exist primarily for relocation and normally have 1089 // STB_LOCAL binding. 1090 break; 1091 1092 case STT_FILE: 1093 // Conventionally, the symbol's name gives the name of the source 1094 // file associated with the object file. A file symbol has STB_LOCAL 1095 // binding, its section index is SHN_ABS, and it precedes the other 1096 // STB_LOCAL symbols for the file, if it is present. 1097 symbol_type = eSymbolTypeSourceFile; 1098 break; 1099 1100 case STT_GNU_IFUNC: 1101 // The symbol is associated with an indirect function. The actual 1102 // function will be resolved if it is referenced. 1103 symbol_type = eSymbolTypeResolver; 1104 break; 1105 } 1106 } 1107 1108 if (symbol_type == eSymbolTypeInvalid) 1109 { 1110 if (symbol_section_sp) 1111 { 1112 const ConstString §_name = symbol_section_sp->GetName(); 1113 if (sect_name == text_section_name || 1114 sect_name == init_section_name || 1115 sect_name == fini_section_name || 1116 sect_name == ctors_section_name || 1117 sect_name == dtors_section_name) 1118 { 1119 symbol_type = eSymbolTypeCode; 1120 } 1121 else if (sect_name == data_section_name || 1122 sect_name == data2_section_name || 1123 sect_name == rodata_section_name || 1124 sect_name == rodata1_section_name || 1125 sect_name == bss_section_name) 1126 { 1127 symbol_type = eSymbolTypeData; 1128 } 1129 } 1130 } 1131 1132 // If the symbol section we've found has no data (SHT_NOBITS), then check the module section 1133 // list. This can happen if we're parsing the debug file and 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 SectionList *module_section_list = module_sp->GetSectionList(); 1140 if (module_section_list && module_section_list != section_list) 1141 { 1142 const ConstString §_name = symbol_section_sp->GetName(); 1143 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1144 if (section_sp && section_sp->GetFileSize()) 1145 { 1146 symbol_section_sp = section_sp; 1147 } 1148 } 1149 } 1150 } 1151 1152 uint64_t symbol_value = symbol.st_value; 1153 if (symbol_section_sp) 1154 symbol_value -= symbol_section_sp->GetFileAddress(); 1155 bool is_global = symbol.getBinding() == STB_GLOBAL; 1156 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1157 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1158 Symbol dc_symbol( 1159 i + start_id, // ID is the original symbol table index. 1160 symbol_name, // Symbol name. 1161 is_mangled, // Is the symbol name mangled? 1162 symbol_type, // Type of this symbol 1163 is_global, // Is this globally visible? 1164 false, // Is this symbol debug info? 1165 false, // Is this symbol a trampoline? 1166 false, // Is this symbol artificial? 1167 symbol_section_sp, // Section in which this symbol is defined or null. 1168 symbol_value, // Offset in section or symbol value. 1169 symbol.st_size, // Size in bytes of this symbol. 1170 true, // Size is valid 1171 flags); // Symbol flags. 1172 symtab->AddSymbol(dc_symbol); 1173 } 1174 1175 return i; 1176} 1177 1178unsigned 1179ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 1180{ 1181 if (symtab->GetObjectFile() != this) 1182 { 1183 // If the symbol table section is owned by a different object file, have it do the 1184 // parsing. 1185 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 1186 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 1187 } 1188 1189 // Get section list for this object file. 1190 SectionList *section_list = m_sections_ap.get(); 1191 if (!section_list) 1192 return 0; 1193 1194 user_id_t symtab_id = symtab->GetID(); 1195 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 1196 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1197 symtab_hdr->sh_type == SHT_DYNSYM); 1198 1199 // sh_link: section header index of associated string table. 1200 // Section ID's are ones based. 1201 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1202 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1203 1204 unsigned num_symbols = 0; 1205 if (symtab && strtab) 1206 { 1207 assert (symtab->GetObjectFile() == this); 1208 assert (strtab->GetObjectFile() == this); 1209 1210 DataExtractor symtab_data; 1211 DataExtractor strtab_data; 1212 if (ReadSectionData(symtab, symtab_data) && 1213 ReadSectionData(strtab, strtab_data)) 1214 { 1215 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 1216 1217 num_symbols = ParseSymbols(symbol_table, start_id, 1218 section_list, num_symbols, 1219 symtab_data, strtab_data); 1220 } 1221 } 1222 1223 return num_symbols; 1224} 1225 1226size_t 1227ObjectFileELF::ParseDynamicSymbols() 1228{ 1229 if (m_dynamic_symbols.size()) 1230 return m_dynamic_symbols.size(); 1231 1232 SectionList *section_list = GetSectionList(); 1233 if (!section_list) 1234 return 0; 1235 1236 // Find the SHT_DYNAMIC section. 1237 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1238 if (!dynsym) 1239 return 0; 1240 assert (dynsym->GetObjectFile() == this); 1241 1242 ELFDynamic symbol; 1243 DataExtractor dynsym_data; 1244 if (ReadSectionData(dynsym, dynsym_data)) 1245 { 1246 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1247 lldb::offset_t cursor = 0; 1248 1249 while (cursor < section_size) 1250 { 1251 if (!symbol.Parse(dynsym_data, &cursor)) 1252 break; 1253 1254 m_dynamic_symbols.push_back(symbol); 1255 } 1256 } 1257 1258 return m_dynamic_symbols.size(); 1259} 1260 1261const ELFDynamic * 1262ObjectFileELF::FindDynamicSymbol(unsigned tag) 1263{ 1264 if (!ParseDynamicSymbols()) 1265 return NULL; 1266 1267 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1268 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1269 for ( ; I != E; ++I) 1270 { 1271 ELFDynamic *symbol = &*I; 1272 1273 if (symbol->d_tag == tag) 1274 return symbol; 1275 } 1276 1277 return NULL; 1278} 1279 1280unsigned 1281ObjectFileELF::PLTRelocationType() 1282{ 1283 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1284 1285 if (symbol) 1286 return symbol->d_val; 1287 1288 return 0; 1289} 1290 1291static unsigned 1292ParsePLTRelocations(Symtab *symbol_table, 1293 user_id_t start_id, 1294 unsigned rel_type, 1295 const ELFHeader *hdr, 1296 const ELFSectionHeader *rel_hdr, 1297 const ELFSectionHeader *plt_hdr, 1298 const ELFSectionHeader *sym_hdr, 1299 const lldb::SectionSP &plt_section_sp, 1300 DataExtractor &rel_data, 1301 DataExtractor &symtab_data, 1302 DataExtractor &strtab_data) 1303{ 1304 ELFRelocation rel(rel_type); 1305 ELFSymbol symbol; 1306 lldb::offset_t offset = 0; 1307 const elf_xword plt_entsize = plt_hdr->sh_entsize; 1308 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1309 1310 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1311 reloc_info_fn reloc_type; 1312 reloc_info_fn reloc_symbol; 1313 1314 if (hdr->Is32Bit()) 1315 { 1316 reloc_type = ELFRelocation::RelocType32; 1317 reloc_symbol = ELFRelocation::RelocSymbol32; 1318 } 1319 else 1320 { 1321 reloc_type = ELFRelocation::RelocType64; 1322 reloc_symbol = ELFRelocation::RelocSymbol64; 1323 } 1324 1325 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1326 unsigned i; 1327 for (i = 0; i < num_relocations; ++i) 1328 { 1329 if (rel.Parse(rel_data, &offset) == false) 1330 break; 1331 1332 if (reloc_type(rel) != slot_type) 1333 continue; 1334 1335 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1336 uint64_t plt_index = (i + 1) * plt_entsize; 1337 1338 if (!symbol.Parse(symtab_data, &symbol_offset)) 1339 break; 1340 1341 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1342 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1343 1344 Symbol jump_symbol( 1345 i + start_id, // Symbol table index 1346 symbol_name, // symbol name. 1347 is_mangled, // is the symbol name mangled? 1348 eSymbolTypeTrampoline, // Type of this symbol 1349 false, // Is this globally visible? 1350 false, // Is this symbol debug info? 1351 true, // Is this symbol a trampoline? 1352 true, // Is this symbol artificial? 1353 plt_section_sp, // Section in which this symbol is defined or null. 1354 plt_index, // Offset in section or symbol value. 1355 plt_entsize, // Size in bytes of this symbol. 1356 true, // Size is valid 1357 0); // Symbol flags. 1358 1359 symbol_table->AddSymbol(jump_symbol); 1360 } 1361 1362 return i; 1363} 1364 1365unsigned 1366ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 1367 user_id_t start_id, 1368 const ELFSectionHeaderInfo *rel_hdr, 1369 user_id_t rel_id) 1370{ 1371 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 1372 1373 // The link field points to the associated symbol table. The info field 1374 // points to the section holding the plt. 1375 user_id_t symtab_id = rel_hdr->sh_link; 1376 user_id_t plt_id = rel_hdr->sh_info; 1377 1378 if (!symtab_id || !plt_id) 1379 return 0; 1380 1381 // Section ID's are ones based; 1382 symtab_id++; 1383 plt_id++; 1384 1385 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 1386 if (!plt_hdr) 1387 return 0; 1388 1389 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 1390 if (!sym_hdr) 1391 return 0; 1392 1393 SectionList *section_list = m_sections_ap.get(); 1394 if (!section_list) 1395 return 0; 1396 1397 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 1398 if (!rel_section) 1399 return 0; 1400 1401 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 1402 if (!plt_section_sp) 1403 return 0; 1404 1405 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1406 if (!symtab) 1407 return 0; 1408 1409 // sh_link points to associated string table. 1410 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 1411 if (!strtab) 1412 return 0; 1413 1414 DataExtractor rel_data; 1415 if (!ReadSectionData(rel_section, rel_data)) 1416 return 0; 1417 1418 DataExtractor symtab_data; 1419 if (!ReadSectionData(symtab, symtab_data)) 1420 return 0; 1421 1422 DataExtractor strtab_data; 1423 if (!ReadSectionData(strtab, strtab_data)) 1424 return 0; 1425 1426 unsigned rel_type = PLTRelocationType(); 1427 if (!rel_type) 1428 return 0; 1429 1430 return ParsePLTRelocations (symbol_table, 1431 start_id, 1432 rel_type, 1433 &m_header, 1434 rel_hdr, 1435 plt_hdr, 1436 sym_hdr, 1437 plt_section_sp, 1438 rel_data, 1439 symtab_data, 1440 strtab_data); 1441} 1442 1443Symtab * 1444ObjectFileELF::GetSymtab() 1445{ 1446 ModuleSP module_sp(GetModule()); 1447 if (!module_sp) 1448 return NULL; 1449 1450 // We always want to use the main object file so we (hopefully) only have one cached copy 1451 // of our symtab, dynamic sections, etc. 1452 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 1453 if (module_obj_file && module_obj_file != this) 1454 return module_obj_file->GetSymtab(); 1455 1456 if (m_symtab_ap.get() == NULL) 1457 { 1458 SectionList *section_list = GetSectionList(); 1459 if (!section_list) 1460 return NULL; 1461 1462 uint64_t symbol_id = 0; 1463 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 1464 1465 m_symtab_ap.reset(new Symtab(this)); 1466 1467 // Sharable objects and dynamic executables usually have 2 distinct symbol 1468 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 1469 // version of the symtab that only contains global symbols. The information found 1470 // in the dynsym is therefore also found in the symtab, while the reverse is not 1471 // necessarily true. 1472 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 1473 if (!symtab) 1474 { 1475 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 1476 // then use the dynsym section which should always be there. 1477 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 1478 } 1479 if (symtab) 1480 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 1481 1482 // Synthesize trampoline symbols to help navigate the PLT. 1483 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 1484 if (symbol) 1485 { 1486 addr_t addr = symbol->d_ptr; 1487 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 1488 if (reloc_section) 1489 { 1490 user_id_t reloc_id = reloc_section->GetID(); 1491 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 1492 assert(reloc_header); 1493 1494 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 1495 } 1496 } 1497 } 1498 return m_symtab_ap.get(); 1499} 1500 1501bool 1502ObjectFileELF::IsStripped () 1503{ 1504 // TODO: determine this for ELF 1505 return false; 1506} 1507 1508//===----------------------------------------------------------------------===// 1509// Dump 1510// 1511// Dump the specifics of the runtime file container (such as any headers 1512// segments, sections, etc). 1513//---------------------------------------------------------------------- 1514void 1515ObjectFileELF::Dump(Stream *s) 1516{ 1517 DumpELFHeader(s, m_header); 1518 s->EOL(); 1519 DumpELFProgramHeaders(s); 1520 s->EOL(); 1521 DumpELFSectionHeaders(s); 1522 s->EOL(); 1523 SectionList *section_list = GetSectionList(); 1524 if (section_list) 1525 section_list->Dump(s, NULL, true, UINT32_MAX); 1526 Symtab *symtab = GetSymtab(); 1527 if (symtab) 1528 symtab->Dump(s, NULL, eSortOrderNone); 1529 s->EOL(); 1530 DumpDependentModules(s); 1531 s->EOL(); 1532} 1533 1534//---------------------------------------------------------------------- 1535// DumpELFHeader 1536// 1537// Dump the ELF header to the specified output stream 1538//---------------------------------------------------------------------- 1539void 1540ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 1541{ 1542 s->PutCString("ELF Header\n"); 1543 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 1544 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 1545 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 1546 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 1547 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 1548 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 1549 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 1550 1551 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 1552 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 1553 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 1554 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 1555 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 1556 1557 s->Printf("e_type = 0x%4.4x ", header.e_type); 1558 DumpELFHeader_e_type(s, header.e_type); 1559 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 1560 s->Printf("e_version = 0x%8.8x\n", header.e_version); 1561 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 1562 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 1563 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 1564 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 1565 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 1566 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 1567 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 1568 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 1569 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 1570 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 1571} 1572 1573//---------------------------------------------------------------------- 1574// DumpELFHeader_e_type 1575// 1576// Dump an token value for the ELF header member e_type 1577//---------------------------------------------------------------------- 1578void 1579ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 1580{ 1581 switch (e_type) 1582 { 1583 case ET_NONE: *s << "ET_NONE"; break; 1584 case ET_REL: *s << "ET_REL"; break; 1585 case ET_EXEC: *s << "ET_EXEC"; break; 1586 case ET_DYN: *s << "ET_DYN"; break; 1587 case ET_CORE: *s << "ET_CORE"; break; 1588 default: 1589 break; 1590 } 1591} 1592 1593//---------------------------------------------------------------------- 1594// DumpELFHeader_e_ident_EI_DATA 1595// 1596// Dump an token value for the ELF header member e_ident[EI_DATA] 1597//---------------------------------------------------------------------- 1598void 1599ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 1600{ 1601 switch (ei_data) 1602 { 1603 case ELFDATANONE: *s << "ELFDATANONE"; break; 1604 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 1605 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 1606 default: 1607 break; 1608 } 1609} 1610 1611 1612//---------------------------------------------------------------------- 1613// DumpELFProgramHeader 1614// 1615// Dump a single ELF program header to the specified output stream 1616//---------------------------------------------------------------------- 1617void 1618ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 1619{ 1620 DumpELFProgramHeader_p_type(s, ph.p_type); 1621 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 1622 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 1623 1624 DumpELFProgramHeader_p_flags(s, ph.p_flags); 1625 s->Printf(") %8.8" PRIx64, ph.p_align); 1626} 1627 1628//---------------------------------------------------------------------- 1629// DumpELFProgramHeader_p_type 1630// 1631// Dump an token value for the ELF program header member p_type which 1632// describes the type of the program header 1633// ---------------------------------------------------------------------- 1634void 1635ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 1636{ 1637 const int kStrWidth = 15; 1638 switch (p_type) 1639 { 1640 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 1641 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 1642 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 1643 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 1644 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 1645 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 1646 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 1647 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 1648 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 1649 default: 1650 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 1651 break; 1652 } 1653} 1654 1655 1656//---------------------------------------------------------------------- 1657// DumpELFProgramHeader_p_flags 1658// 1659// Dump an token value for the ELF program header member p_flags 1660//---------------------------------------------------------------------- 1661void 1662ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 1663{ 1664 *s << ((p_flags & PF_X) ? "PF_X" : " ") 1665 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 1666 << ((p_flags & PF_W) ? "PF_W" : " ") 1667 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 1668 << ((p_flags & PF_R) ? "PF_R" : " "); 1669} 1670 1671//---------------------------------------------------------------------- 1672// DumpELFProgramHeaders 1673// 1674// Dump all of the ELF program header to the specified output stream 1675//---------------------------------------------------------------------- 1676void 1677ObjectFileELF::DumpELFProgramHeaders(Stream *s) 1678{ 1679 if (ParseProgramHeaders()) 1680 { 1681 s->PutCString("Program Headers\n"); 1682 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 1683 "p_filesz p_memsz p_flags p_align\n"); 1684 s->PutCString("==== --------------- -------- -------- -------- " 1685 "-------- -------- ------------------------- --------\n"); 1686 1687 uint32_t idx = 0; 1688 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 1689 I != m_program_headers.end(); ++I, ++idx) 1690 { 1691 s->Printf("[%2u] ", idx); 1692 ObjectFileELF::DumpELFProgramHeader(s, *I); 1693 s->EOL(); 1694 } 1695 } 1696} 1697 1698//---------------------------------------------------------------------- 1699// DumpELFSectionHeader 1700// 1701// Dump a single ELF section header to the specified output stream 1702//---------------------------------------------------------------------- 1703void 1704ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 1705{ 1706 s->Printf("%8.8x ", sh.sh_name); 1707 DumpELFSectionHeader_sh_type(s, sh.sh_type); 1708 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 1709 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 1710 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 1711 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 1712 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 1713} 1714 1715//---------------------------------------------------------------------- 1716// DumpELFSectionHeader_sh_type 1717// 1718// Dump an token value for the ELF section header member sh_type which 1719// describes the type of the section 1720//---------------------------------------------------------------------- 1721void 1722ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 1723{ 1724 const int kStrWidth = 12; 1725 switch (sh_type) 1726 { 1727 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 1728 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 1729 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 1730 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 1731 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 1732 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 1733 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 1734 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 1735 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 1736 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 1737 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 1738 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 1739 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 1740 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 1741 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 1742 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 1743 default: 1744 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 1745 break; 1746 } 1747} 1748 1749//---------------------------------------------------------------------- 1750// DumpELFSectionHeader_sh_flags 1751// 1752// Dump an token value for the ELF section header member sh_flags 1753//---------------------------------------------------------------------- 1754void 1755ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 1756{ 1757 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 1758 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 1759 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 1760 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 1761 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 1762} 1763 1764//---------------------------------------------------------------------- 1765// DumpELFSectionHeaders 1766// 1767// Dump all of the ELF section header to the specified output stream 1768//---------------------------------------------------------------------- 1769void 1770ObjectFileELF::DumpELFSectionHeaders(Stream *s) 1771{ 1772 if (!ParseSectionHeaders()) 1773 return; 1774 1775 s->PutCString("Section Headers\n"); 1776 s->PutCString("IDX name type flags " 1777 "addr offset size link info addralgn " 1778 "entsize Name\n"); 1779 s->PutCString("==== -------- ------------ -------------------------------- " 1780 "-------- -------- -------- -------- -------- -------- " 1781 "-------- ====================\n"); 1782 1783 uint32_t idx = 0; 1784 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 1785 I != m_section_headers.end(); ++I, ++idx) 1786 { 1787 s->Printf("[%2u] ", idx); 1788 ObjectFileELF::DumpELFSectionHeader(s, *I); 1789 const char* section_name = I->section_name.AsCString(""); 1790 if (section_name) 1791 *s << ' ' << section_name << "\n"; 1792 } 1793} 1794 1795void 1796ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 1797{ 1798 size_t num_modules = ParseDependentModules(); 1799 1800 if (num_modules > 0) 1801 { 1802 s->PutCString("Dependent Modules:\n"); 1803 for (unsigned i = 0; i < num_modules; ++i) 1804 { 1805 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 1806 s->Printf(" %s\n", spec.GetFilename().GetCString()); 1807 } 1808 } 1809} 1810 1811bool 1812ObjectFileELF::GetArchitecture (ArchSpec &arch) 1813{ 1814 if (!ParseHeader()) 1815 return false; 1816 1817 arch.SetArchitecture (eArchTypeELF, m_header.e_machine, LLDB_INVALID_CPUTYPE); 1818 arch.GetTriple().setOSName (Host::GetOSString().GetCString()); 1819 arch.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1820 return true; 1821} 1822 1823ObjectFile::Type 1824ObjectFileELF::CalculateType() 1825{ 1826 switch (m_header.e_type) 1827 { 1828 case llvm::ELF::ET_NONE: 1829 // 0 - No file type 1830 return eTypeUnknown; 1831 1832 case llvm::ELF::ET_REL: 1833 // 1 - Relocatable file 1834 return eTypeObjectFile; 1835 1836 case llvm::ELF::ET_EXEC: 1837 // 2 - Executable file 1838 return eTypeExecutable; 1839 1840 case llvm::ELF::ET_DYN: 1841 // 3 - Shared object file 1842 return eTypeSharedLibrary; 1843 1844 case ET_CORE: 1845 // 4 - Core file 1846 return eTypeCoreFile; 1847 1848 default: 1849 break; 1850 } 1851 return eTypeUnknown; 1852} 1853 1854ObjectFile::Strata 1855ObjectFileELF::CalculateStrata() 1856{ 1857 switch (m_header.e_type) 1858 { 1859 case llvm::ELF::ET_NONE: 1860 // 0 - No file type 1861 return eStrataUnknown; 1862 1863 case llvm::ELF::ET_REL: 1864 // 1 - Relocatable file 1865 return eStrataUnknown; 1866 1867 case llvm::ELF::ET_EXEC: 1868 // 2 - Executable file 1869 // TODO: is there any way to detect that an executable is a kernel 1870 // related executable by inspecting the program headers, section 1871 // headers, symbols, or any other flag bits??? 1872 return eStrataUser; 1873 1874 case llvm::ELF::ET_DYN: 1875 // 3 - Shared object file 1876 // TODO: is there any way to detect that an shared library is a kernel 1877 // related executable by inspecting the program headers, section 1878 // headers, symbols, or any other flag bits??? 1879 return eStrataUnknown; 1880 1881 case ET_CORE: 1882 // 4 - Core file 1883 // TODO: is there any way to detect that an core file is a kernel 1884 // related executable by inspecting the program headers, section 1885 // headers, symbols, or any other flag bits??? 1886 return eStrataUnknown; 1887 1888 default: 1889 break; 1890 } 1891 return eStrataUnknown; 1892} 1893 1894