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/Log.h" 20 #include "lldb/Core/Module.h" 21 #include "lldb/Core/ModuleSpec.h" 22 #include "lldb/Core/PluginManager.h" 23 #include "lldb/Core/Section.h" 24 #include "lldb/Core/Stream.h" 25 #include "lldb/Core/Timer.h" 26 #include "lldb/Symbol/DWARFCallFrameInfo.h" 27 #include "lldb/Symbol/SymbolContext.h" 28 #include "lldb/Target/SectionLoadList.h" 29 #include "lldb/Target/Target.h" 30 #include "lldb/Host/Host.h" 31 32 #include "llvm/ADT/PointerUnion.h" 33 #include "llvm/Support/MathExtras.h" 34 35 #define CASE_AND_STREAM(s, def, width) \ 36 case def: s->Printf("%-*s", width, #def); break; 37 38 using namespace lldb; 39 using namespace lldb_private; 40 using namespace elf; 41 using namespace llvm::ELF; 42 43 namespace { 44 45 // ELF note owner definitions 46 const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD"; 47 const char *const LLDB_NT_OWNER_GNU = "GNU"; 48 const char *const LLDB_NT_OWNER_NETBSD = "NetBSD"; 49 50 // ELF note type definitions 51 const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01; 52 const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4; 53 54 const elf_word LLDB_NT_GNU_ABI_TAG = 0x01; 55 const elf_word LLDB_NT_GNU_ABI_SIZE = 16; 56 57 const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03; 58 59 const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01; 60 const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4; 61 62 // GNU ABI note OS constants 63 const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00; 64 const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01; 65 const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02; 66 67 //===----------------------------------------------------------------------===// 68 /// @class ELFRelocation 69 /// @brief Generic wrapper for ELFRel and ELFRela. 70 /// 71 /// This helper class allows us to parse both ELFRel and ELFRela relocation 72 /// entries in a generic manner. 73 class ELFRelocation 74 { 75 public: 76 77 /// Constructs an ELFRelocation entry with a personality as given by @p 78 /// type. 79 /// 80 /// @param type Either DT_REL or DT_RELA. Any other value is invalid. 81 ELFRelocation(unsigned type); 82 83 ~ELFRelocation(); 84 85 bool 86 Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); 87 88 static unsigned 89 RelocType32(const ELFRelocation &rel); 90 91 static unsigned 92 RelocType64(const ELFRelocation &rel); 93 94 static unsigned 95 RelocSymbol32(const ELFRelocation &rel); 96 97 static unsigned 98 RelocSymbol64(const ELFRelocation &rel); 99 100 static unsigned 101 RelocOffset32(const ELFRelocation &rel); 102 103 static unsigned 104 RelocOffset64(const ELFRelocation &rel); 105 106 static unsigned 107 RelocAddend32(const ELFRelocation &rel); 108 109 static unsigned 110 RelocAddend64(const ELFRelocation &rel); 111 112 private: 113 typedef llvm::PointerUnion<ELFRel*, ELFRela*> RelocUnion; 114 115 RelocUnion reloc; 116 }; 117 118 ELFRelocation::ELFRelocation(unsigned type) 119 { 120 if (type == DT_REL || type == SHT_REL) 121 reloc = new ELFRel(); 122 else if (type == DT_RELA || type == SHT_RELA) 123 reloc = new ELFRela(); 124 else { 125 assert(false && "unexpected relocation type"); 126 reloc = static_cast<ELFRel*>(NULL); 127 } 128 } 129 130 ELFRelocation::~ELFRelocation() 131 { 132 if (reloc.is<ELFRel*>()) 133 delete reloc.get<ELFRel*>(); 134 else 135 delete reloc.get<ELFRela*>(); 136 } 137 138 bool 139 ELFRelocation::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 140 { 141 if (reloc.is<ELFRel*>()) 142 return reloc.get<ELFRel*>()->Parse(data, offset); 143 else 144 return reloc.get<ELFRela*>()->Parse(data, offset); 145 } 146 147 unsigned 148 ELFRelocation::RelocType32(const ELFRelocation &rel) 149 { 150 if (rel.reloc.is<ELFRel*>()) 151 return ELFRel::RelocType32(*rel.reloc.get<ELFRel*>()); 152 else 153 return ELFRela::RelocType32(*rel.reloc.get<ELFRela*>()); 154 } 155 156 unsigned 157 ELFRelocation::RelocType64(const ELFRelocation &rel) 158 { 159 if (rel.reloc.is<ELFRel*>()) 160 return ELFRel::RelocType64(*rel.reloc.get<ELFRel*>()); 161 else 162 return ELFRela::RelocType64(*rel.reloc.get<ELFRela*>()); 163 } 164 165 unsigned 166 ELFRelocation::RelocSymbol32(const ELFRelocation &rel) 167 { 168 if (rel.reloc.is<ELFRel*>()) 169 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel*>()); 170 else 171 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela*>()); 172 } 173 174 unsigned 175 ELFRelocation::RelocSymbol64(const ELFRelocation &rel) 176 { 177 if (rel.reloc.is<ELFRel*>()) 178 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel*>()); 179 else 180 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela*>()); 181 } 182 183 unsigned 184 ELFRelocation::RelocOffset32(const ELFRelocation &rel) 185 { 186 if (rel.reloc.is<ELFRel*>()) 187 return rel.reloc.get<ELFRel*>()->r_offset; 188 else 189 return rel.reloc.get<ELFRela*>()->r_offset; 190 } 191 192 unsigned 193 ELFRelocation::RelocOffset64(const ELFRelocation &rel) 194 { 195 if (rel.reloc.is<ELFRel*>()) 196 return rel.reloc.get<ELFRel*>()->r_offset; 197 else 198 return rel.reloc.get<ELFRela*>()->r_offset; 199 } 200 201 unsigned 202 ELFRelocation::RelocAddend32(const ELFRelocation &rel) 203 { 204 if (rel.reloc.is<ELFRel*>()) 205 return 0; 206 else 207 return rel.reloc.get<ELFRela*>()->r_addend; 208 } 209 210 unsigned 211 ELFRelocation::RelocAddend64(const ELFRelocation &rel) 212 { 213 if (rel.reloc.is<ELFRel*>()) 214 return 0; 215 else 216 return rel.reloc.get<ELFRela*>()->r_addend; 217 } 218 219 } // end anonymous namespace 220 221 bool 222 ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) 223 { 224 // Read all fields. 225 if (data.GetU32(offset, &n_namesz, 3) == NULL) 226 return false; 227 228 // The name field is required to be nul-terminated, and n_namesz 229 // includes the terminating nul in observed implementations (contrary 230 // to the ELF-64 spec). A special case is needed for cores generated 231 // by some older Linux versions, which write a note named "CORE" 232 // without a nul terminator and n_namesz = 4. 233 if (n_namesz == 4) 234 { 235 char buf[4]; 236 if (data.ExtractBytes (*offset, 4, data.GetByteOrder(), buf) != 4) 237 return false; 238 if (strncmp (buf, "CORE", 4) == 0) 239 { 240 n_name = "CORE"; 241 *offset += 4; 242 return true; 243 } 244 } 245 246 const char *cstr = data.GetCStr(offset, llvm::RoundUpToAlignment (n_namesz, 4)); 247 if (cstr == NULL) 248 { 249 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS)); 250 if (log) 251 log->Printf("Failed to parse note name lacking nul terminator"); 252 253 return false; 254 } 255 n_name = cstr; 256 return true; 257 } 258 259 // Arbitrary constant used as UUID prefix for core files. 260 const uint32_t 261 ObjectFileELF::g_core_uuid_magic(0xE210C); 262 263 //------------------------------------------------------------------ 264 // Static methods. 265 //------------------------------------------------------------------ 266 void 267 ObjectFileELF::Initialize() 268 { 269 PluginManager::RegisterPlugin(GetPluginNameStatic(), 270 GetPluginDescriptionStatic(), 271 CreateInstance, 272 CreateMemoryInstance, 273 GetModuleSpecifications); 274 } 275 276 void 277 ObjectFileELF::Terminate() 278 { 279 PluginManager::UnregisterPlugin(CreateInstance); 280 } 281 282 lldb_private::ConstString 283 ObjectFileELF::GetPluginNameStatic() 284 { 285 static ConstString g_name("elf"); 286 return g_name; 287 } 288 289 const char * 290 ObjectFileELF::GetPluginDescriptionStatic() 291 { 292 return "ELF object file reader."; 293 } 294 295 ObjectFile * 296 ObjectFileELF::CreateInstance (const lldb::ModuleSP &module_sp, 297 DataBufferSP &data_sp, 298 lldb::offset_t data_offset, 299 const lldb_private::FileSpec* file, 300 lldb::offset_t file_offset, 301 lldb::offset_t length) 302 { 303 if (!data_sp) 304 { 305 data_sp = file->MemoryMapFileContents(file_offset, length); 306 data_offset = 0; 307 } 308 309 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 310 { 311 const uint8_t *magic = data_sp->GetBytes() + data_offset; 312 if (ELFHeader::MagicBytesMatch(magic)) 313 { 314 // Update the data to contain the entire file if it doesn't already 315 if (data_sp->GetByteSize() < length) { 316 data_sp = file->MemoryMapFileContents(file_offset, length); 317 data_offset = 0; 318 magic = data_sp->GetBytes(); 319 } 320 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 321 if (address_size == 4 || address_size == 8) 322 { 323 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, data_offset, file, file_offset, length)); 324 ArchSpec spec; 325 if (objfile_ap->GetArchitecture(spec) && 326 objfile_ap->SetModulesArchitecture(spec)) 327 return objfile_ap.release(); 328 } 329 } 330 } 331 return NULL; 332 } 333 334 335 ObjectFile* 336 ObjectFileELF::CreateMemoryInstance (const lldb::ModuleSP &module_sp, 337 DataBufferSP& data_sp, 338 const lldb::ProcessSP &process_sp, 339 lldb::addr_t header_addr) 340 { 341 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) 342 { 343 const uint8_t *magic = data_sp->GetBytes(); 344 if (ELFHeader::MagicBytesMatch(magic)) 345 { 346 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 347 if (address_size == 4 || address_size == 8) 348 { 349 std::auto_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, process_sp, header_addr)); 350 ArchSpec spec; 351 if (objfile_ap->GetArchitecture(spec) && 352 objfile_ap->SetModulesArchitecture(spec)) 353 return objfile_ap.release(); 354 } 355 } 356 } 357 return NULL; 358 } 359 360 bool 361 ObjectFileELF::MagicBytesMatch (DataBufferSP& data_sp, 362 lldb::addr_t data_offset, 363 lldb::addr_t data_length) 364 { 365 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 366 { 367 const uint8_t *magic = data_sp->GetBytes() + data_offset; 368 return ELFHeader::MagicBytesMatch(magic); 369 } 370 return false; 371 } 372 373 /* 374 * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c 375 * 376 * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or 377 * code or tables extracted from it, as desired without restriction. 378 */ 379 static uint32_t 380 calc_crc32(uint32_t crc, const void *buf, size_t size) 381 { 382 static const uint32_t g_crc32_tab[] = 383 { 384 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 385 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 386 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 387 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 388 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 389 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 390 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 391 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 392 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 393 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 394 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 395 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 396 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 397 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 398 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 399 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 400 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 401 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 402 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 403 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 404 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 405 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 406 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 407 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 408 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 409 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 410 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 411 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 412 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 413 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 414 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 415 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 416 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 417 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 418 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 419 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 420 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 421 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 422 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 423 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 424 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 425 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 426 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 427 }; 428 const uint8_t *p = (const uint8_t *)buf; 429 430 crc = crc ^ ~0U; 431 while (size--) 432 crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); 433 return crc ^ ~0U; 434 } 435 436 static uint32_t 437 calc_gnu_debuglink_crc32(const void *buf, size_t size) 438 { 439 return calc_crc32(0U, buf, size); 440 } 441 442 uint32_t 443 ObjectFileELF::CalculateELFNotesSegmentsCRC32 (const ProgramHeaderColl& program_headers, 444 DataExtractor& object_data) 445 { 446 typedef ProgramHeaderCollConstIter Iter; 447 448 uint32_t core_notes_crc = 0; 449 450 for (Iter I = program_headers.begin(); I != program_headers.end(); ++I) 451 { 452 if (I->p_type == llvm::ELF::PT_NOTE) 453 { 454 const elf_off ph_offset = I->p_offset; 455 const size_t ph_size = I->p_filesz; 456 457 DataExtractor segment_data; 458 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) 459 { 460 // The ELF program header contained incorrect data, 461 // probably corefile is incomplete or corrupted. 462 break; 463 } 464 465 core_notes_crc = calc_crc32(core_notes_crc, 466 segment_data.GetDataStart(), 467 segment_data.GetByteSize()); 468 } 469 } 470 471 return core_notes_crc; 472 } 473 474 static const char* 475 OSABIAsCString (unsigned char osabi_byte) 476 { 477 #define _MAKE_OSABI_CASE(x) case x: return #x 478 switch (osabi_byte) 479 { 480 _MAKE_OSABI_CASE(ELFOSABI_NONE); 481 _MAKE_OSABI_CASE(ELFOSABI_HPUX); 482 _MAKE_OSABI_CASE(ELFOSABI_NETBSD); 483 _MAKE_OSABI_CASE(ELFOSABI_GNU); 484 _MAKE_OSABI_CASE(ELFOSABI_HURD); 485 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS); 486 _MAKE_OSABI_CASE(ELFOSABI_AIX); 487 _MAKE_OSABI_CASE(ELFOSABI_IRIX); 488 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD); 489 _MAKE_OSABI_CASE(ELFOSABI_TRU64); 490 _MAKE_OSABI_CASE(ELFOSABI_MODESTO); 491 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD); 492 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS); 493 _MAKE_OSABI_CASE(ELFOSABI_NSK); 494 _MAKE_OSABI_CASE(ELFOSABI_AROS); 495 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS); 496 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI); 497 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX); 498 _MAKE_OSABI_CASE(ELFOSABI_ARM); 499 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE); 500 default: 501 return "<unknown-osabi>"; 502 } 503 #undef _MAKE_OSABI_CASE 504 } 505 506 static bool 507 GetOsFromOSABI (unsigned char osabi_byte, llvm::Triple::OSType &ostype) 508 { 509 switch (osabi_byte) 510 { 511 case ELFOSABI_AIX: ostype = llvm::Triple::OSType::AIX; break; 512 case ELFOSABI_FREEBSD: ostype = llvm::Triple::OSType::FreeBSD; break; 513 case ELFOSABI_GNU: ostype = llvm::Triple::OSType::Linux; break; 514 case ELFOSABI_NETBSD: ostype = llvm::Triple::OSType::NetBSD; break; 515 case ELFOSABI_OPENBSD: ostype = llvm::Triple::OSType::OpenBSD; break; 516 case ELFOSABI_SOLARIS: ostype = llvm::Triple::OSType::Solaris; break; 517 default: 518 ostype = llvm::Triple::OSType::UnknownOS; 519 } 520 return ostype != llvm::Triple::OSType::UnknownOS; 521 } 522 523 size_t 524 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file, 525 lldb::DataBufferSP& data_sp, 526 lldb::offset_t data_offset, 527 lldb::offset_t file_offset, 528 lldb::offset_t length, 529 lldb_private::ModuleSpecList &specs) 530 { 531 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 532 533 const size_t initial_count = specs.GetSize(); 534 535 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) 536 { 537 DataExtractor data; 538 data.SetData(data_sp); 539 elf::ELFHeader header; 540 if (header.Parse(data, &data_offset)) 541 { 542 if (data_sp) 543 { 544 ModuleSpec spec; 545 spec.GetFileSpec() = file; 546 spec.GetArchitecture().SetArchitecture(eArchTypeELF, 547 header.e_machine, 548 LLDB_INVALID_CPUTYPE); 549 if (spec.GetArchitecture().IsValid()) 550 { 551 llvm::Triple::OSType ostype; 552 // First try to determine the OS type from the OSABI field in the elf header. 553 554 if (log) 555 log->Printf ("ObjectFileELF::%s file '%s' module OSABI: %s", __FUNCTION__, file.GetPath ().c_str (), OSABIAsCString (header.e_ident[EI_OSABI])); 556 if (GetOsFromOSABI (header.e_ident[EI_OSABI], ostype) && ostype != llvm::Triple::OSType::UnknownOS) 557 { 558 spec.GetArchitecture ().GetTriple ().setOS (ostype); 559 560 // Also clear the vendor so we don't end up with situations like 561 // x86_64-apple-FreeBSD. 562 spec.GetArchitecture ().GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 563 564 if (log) 565 log->Printf ("ObjectFileELF::%s file '%s' set ELF module OS type from ELF header OSABI.", __FUNCTION__, file.GetPath ().c_str ()); 566 } 567 568 // Try to get the UUID from the section list. Usually that's at the end, so 569 // map the file in if we don't have it already. 570 size_t section_header_end = header.e_shoff + header.e_shnum * header.e_shentsize; 571 if (section_header_end > data_sp->GetByteSize()) 572 { 573 data_sp = file.MemoryMapFileContents (file_offset, section_header_end); 574 data.SetData(data_sp); 575 } 576 577 uint32_t gnu_debuglink_crc = 0; 578 std::string gnu_debuglink_file; 579 SectionHeaderColl section_headers; 580 lldb_private::UUID &uuid = spec.GetUUID(); 581 582 GetSectionHeaderInfo(section_headers, data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc, spec.GetArchitecture ()); 583 584 // If the module vendor is not set and the module OS matches this host OS, set the module vendor to the host vendor. 585 llvm::Triple &spec_triple = spec.GetArchitecture ().GetTriple (); 586 if (spec_triple.getVendor () == llvm::Triple::VendorType::UnknownVendor) 587 { 588 const llvm::Triple &host_triple = Host::GetArchitecture ().GetTriple (); 589 if (spec_triple.getOS () == host_triple.getOS ()) 590 spec_triple.setVendor (host_triple.getVendor ()); 591 } 592 593 if (log) 594 log->Printf ("ObjectFileELF::%s file '%s' module set to triple: %s (architecture %s)", __FUNCTION__, file.GetPath ().c_str (), spec_triple.getTriple ().c_str (), spec.GetArchitecture ().GetArchitectureName ()); 595 596 if (!uuid.IsValid()) 597 { 598 uint32_t core_notes_crc = 0; 599 600 if (!gnu_debuglink_crc) 601 { 602 lldb_private::Timer scoped_timer (__PRETTY_FUNCTION__, 603 "Calculating module crc32 %s with size %" PRIu64 " KiB", 604 file.GetLastPathComponent().AsCString(), 605 (file.GetByteSize()-file_offset)/1024); 606 607 // For core files - which usually don't happen to have a gnu_debuglink, 608 // and are pretty bulky - calculating whole contents crc32 would be too much of luxury. 609 // Thus we will need to fallback to something simpler. 610 if (header.e_type == llvm::ELF::ET_CORE) 611 { 612 size_t program_headers_end = header.e_phoff + header.e_phnum * header.e_phentsize; 613 if (program_headers_end > data_sp->GetByteSize()) 614 { 615 data_sp = file.MemoryMapFileContents(file_offset, program_headers_end); 616 data.SetData(data_sp); 617 } 618 ProgramHeaderColl program_headers; 619 GetProgramHeaderInfo(program_headers, data, header); 620 621 size_t segment_data_end = 0; 622 for (ProgramHeaderCollConstIter I = program_headers.begin(); 623 I != program_headers.end(); ++I) 624 { 625 segment_data_end = std::max<unsigned long long> (I->p_offset + I->p_filesz, segment_data_end); 626 } 627 628 if (segment_data_end > data_sp->GetByteSize()) 629 { 630 data_sp = file.MemoryMapFileContents(file_offset, segment_data_end); 631 data.SetData(data_sp); 632 } 633 634 core_notes_crc = CalculateELFNotesSegmentsCRC32 (program_headers, data); 635 } 636 else 637 { 638 // Need to map entire file into memory to calculate the crc. 639 data_sp = file.MemoryMapFileContents (file_offset, SIZE_MAX); 640 data.SetData(data_sp); 641 gnu_debuglink_crc = calc_gnu_debuglink_crc32 (data.GetDataStart(), data.GetByteSize()); 642 } 643 } 644 if (gnu_debuglink_crc) 645 { 646 // Use 4 bytes of crc from the .gnu_debuglink section. 647 uint32_t uuidt[4] = { gnu_debuglink_crc, 0, 0, 0 }; 648 uuid.SetBytes (uuidt, sizeof(uuidt)); 649 } 650 else if (core_notes_crc) 651 { 652 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it look different form 653 // .gnu_debuglink crc followed by 4 bytes of note segments crc. 654 uint32_t uuidt[4] = { g_core_uuid_magic, core_notes_crc, 0, 0 }; 655 uuid.SetBytes (uuidt, sizeof(uuidt)); 656 } 657 } 658 659 specs.Append(spec); 660 } 661 } 662 } 663 } 664 665 return specs.GetSize() - initial_count; 666 } 667 668 //------------------------------------------------------------------ 669 // PluginInterface protocol 670 //------------------------------------------------------------------ 671 lldb_private::ConstString 672 ObjectFileELF::GetPluginName() 673 { 674 return GetPluginNameStatic(); 675 } 676 677 uint32_t 678 ObjectFileELF::GetPluginVersion() 679 { 680 return m_plugin_version; 681 } 682 //------------------------------------------------------------------ 683 // ObjectFile protocol 684 //------------------------------------------------------------------ 685 686 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 687 DataBufferSP& data_sp, 688 lldb::offset_t data_offset, 689 const FileSpec* file, 690 lldb::offset_t file_offset, 691 lldb::offset_t length) : 692 ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset), 693 m_header(), 694 m_uuid(), 695 m_gnu_debuglink_file(), 696 m_gnu_debuglink_crc(0), 697 m_program_headers(), 698 m_section_headers(), 699 m_dynamic_symbols(), 700 m_filespec_ap(), 701 m_entry_point_address(), 702 m_arch_spec() 703 { 704 if (file) 705 m_file = *file; 706 ::memset(&m_header, 0, sizeof(m_header)); 707 } 708 709 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 710 DataBufferSP& data_sp, 711 const lldb::ProcessSP &process_sp, 712 addr_t header_addr) : 713 ObjectFile(module_sp, process_sp, LLDB_INVALID_ADDRESS, data_sp), 714 m_header(), 715 m_uuid(), 716 m_gnu_debuglink_file(), 717 m_gnu_debuglink_crc(0), 718 m_program_headers(), 719 m_section_headers(), 720 m_dynamic_symbols(), 721 m_filespec_ap(), 722 m_entry_point_address(), 723 m_arch_spec() 724 { 725 ::memset(&m_header, 0, sizeof(m_header)); 726 } 727 728 ObjectFileELF::~ObjectFileELF() 729 { 730 } 731 732 bool 733 ObjectFileELF::IsExecutable() const 734 { 735 return m_header.e_entry != 0; 736 } 737 738 bool 739 ObjectFileELF::SetLoadAddress (Target &target, 740 lldb::addr_t value, 741 bool value_is_offset) 742 { 743 ModuleSP module_sp = GetModule(); 744 if (module_sp) 745 { 746 size_t num_loaded_sections = 0; 747 SectionList *section_list = GetSectionList (); 748 if (section_list) 749 { 750 if (value_is_offset) 751 { 752 const size_t num_sections = section_list->GetSize(); 753 size_t sect_idx = 0; 754 755 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) 756 { 757 // Iterate through the object file sections to find all 758 // of the sections that have SHF_ALLOC in their flag bits. 759 SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx)); 760 // if (section_sp && !section_sp->IsThreadSpecific()) 761 if (section_sp && section_sp->Test(SHF_ALLOC)) 762 { 763 if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() + value)) 764 ++num_loaded_sections; 765 } 766 } 767 return num_loaded_sections > 0; 768 } 769 else 770 { 771 // Not sure how to slide an ELF file given the base address 772 // of the ELF file in memory 773 } 774 } 775 } 776 return false; // If it changed 777 } 778 779 ByteOrder 780 ObjectFileELF::GetByteOrder() const 781 { 782 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB) 783 return eByteOrderBig; 784 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB) 785 return eByteOrderLittle; 786 return eByteOrderInvalid; 787 } 788 789 uint32_t 790 ObjectFileELF::GetAddressByteSize() const 791 { 792 return m_data.GetAddressByteSize(); 793 } 794 795 size_t 796 ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) 797 { 798 return std::distance(m_section_headers.begin(), I) + 1u; 799 } 800 801 size_t 802 ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const 803 { 804 return std::distance(m_section_headers.begin(), I) + 1u; 805 } 806 807 bool 808 ObjectFileELF::ParseHeader() 809 { 810 lldb::offset_t offset = 0; 811 return m_header.Parse(m_data, &offset); 812 } 813 814 bool 815 ObjectFileELF::GetUUID(lldb_private::UUID* uuid) 816 { 817 // Need to parse the section list to get the UUIDs, so make sure that's been done. 818 if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile) 819 return false; 820 821 if (m_uuid.IsValid()) 822 { 823 // We have the full build id uuid. 824 *uuid = m_uuid; 825 return true; 826 } 827 else if (GetType() == ObjectFile::eTypeCoreFile) 828 { 829 uint32_t core_notes_crc = 0; 830 831 if (!ParseProgramHeaders()) 832 return false; 833 834 core_notes_crc = CalculateELFNotesSegmentsCRC32(m_program_headers, m_data); 835 836 if (core_notes_crc) 837 { 838 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it 839 // look different form .gnu_debuglink crc - followed by 4 bytes of note 840 // segments crc. 841 uint32_t uuidt[4] = { g_core_uuid_magic, core_notes_crc, 0, 0 }; 842 m_uuid.SetBytes (uuidt, sizeof(uuidt)); 843 } 844 } 845 else 846 { 847 if (!m_gnu_debuglink_crc) 848 m_gnu_debuglink_crc = calc_gnu_debuglink_crc32 (m_data.GetDataStart(), m_data.GetByteSize()); 849 if (m_gnu_debuglink_crc) 850 { 851 // Use 4 bytes of crc from the .gnu_debuglink section. 852 uint32_t uuidt[4] = { m_gnu_debuglink_crc, 0, 0, 0 }; 853 m_uuid.SetBytes (uuidt, sizeof(uuidt)); 854 } 855 } 856 857 if (m_uuid.IsValid()) 858 { 859 *uuid = m_uuid; 860 return true; 861 } 862 863 return false; 864 } 865 866 lldb_private::FileSpecList 867 ObjectFileELF::GetDebugSymbolFilePaths() 868 { 869 FileSpecList file_spec_list; 870 871 if (!m_gnu_debuglink_file.empty()) 872 { 873 FileSpec file_spec (m_gnu_debuglink_file.c_str(), false); 874 file_spec_list.Append (file_spec); 875 } 876 return file_spec_list; 877 } 878 879 uint32_t 880 ObjectFileELF::GetDependentModules(FileSpecList &files) 881 { 882 size_t num_modules = ParseDependentModules(); 883 uint32_t num_specs = 0; 884 885 for (unsigned i = 0; i < num_modules; ++i) 886 { 887 if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i))) 888 num_specs++; 889 } 890 891 return num_specs; 892 } 893 894 Address 895 ObjectFileELF::GetImageInfoAddress(Target *target) 896 { 897 if (!ParseDynamicSymbols()) 898 return Address(); 899 900 SectionList *section_list = GetSectionList(); 901 if (!section_list) 902 return Address(); 903 904 // Find the SHT_DYNAMIC (.dynamic) section. 905 SectionSP dynsym_section_sp (section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true)); 906 if (!dynsym_section_sp) 907 return Address(); 908 assert (dynsym_section_sp->GetObjectFile() == this); 909 910 user_id_t dynsym_id = dynsym_section_sp->GetID(); 911 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id); 912 if (!dynsym_hdr) 913 return Address(); 914 915 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) 916 { 917 ELFDynamic &symbol = m_dynamic_symbols[i]; 918 919 if (symbol.d_tag == DT_DEBUG) 920 { 921 // Compute the offset as the number of previous entries plus the 922 // size of d_tag. 923 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 924 return Address(dynsym_section_sp, offset); 925 } 926 else if (symbol.d_tag == DT_MIPS_RLD_MAP && target) 927 { 928 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 929 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target); 930 if (dyn_base == LLDB_INVALID_ADDRESS) 931 return Address(); 932 Address addr; 933 Error error; 934 if (target->ReadPointerFromMemory(dyn_base + offset, false, error, addr)) 935 return addr; 936 } 937 } 938 939 return Address(); 940 } 941 942 lldb_private::Address 943 ObjectFileELF::GetEntryPointAddress () 944 { 945 if (m_entry_point_address.IsValid()) 946 return m_entry_point_address; 947 948 if (!ParseHeader() || !IsExecutable()) 949 return m_entry_point_address; 950 951 SectionList *section_list = GetSectionList(); 952 addr_t offset = m_header.e_entry; 953 954 if (!section_list) 955 m_entry_point_address.SetOffset(offset); 956 else 957 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list); 958 return m_entry_point_address; 959 } 960 961 //---------------------------------------------------------------------- 962 // ParseDependentModules 963 //---------------------------------------------------------------------- 964 size_t 965 ObjectFileELF::ParseDependentModules() 966 { 967 if (m_filespec_ap.get()) 968 return m_filespec_ap->GetSize(); 969 970 m_filespec_ap.reset(new FileSpecList()); 971 972 if (!ParseSectionHeaders()) 973 return 0; 974 975 SectionList *section_list = GetSectionList(); 976 if (!section_list) 977 return 0; 978 979 // Find the SHT_DYNAMIC section. 980 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 981 if (!dynsym) 982 return 0; 983 assert (dynsym->GetObjectFile() == this); 984 985 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex (dynsym->GetID()); 986 if (!header) 987 return 0; 988 // sh_link: section header index of string table used by entries in the section. 989 Section *dynstr = section_list->FindSectionByID (header->sh_link + 1).get(); 990 if (!dynstr) 991 return 0; 992 993 DataExtractor dynsym_data; 994 DataExtractor dynstr_data; 995 if (ReadSectionData(dynsym, dynsym_data) && 996 ReadSectionData(dynstr, dynstr_data)) 997 { 998 ELFDynamic symbol; 999 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1000 lldb::offset_t offset = 0; 1001 1002 // The only type of entries we are concerned with are tagged DT_NEEDED, 1003 // yielding the name of a required library. 1004 while (offset < section_size) 1005 { 1006 if (!symbol.Parse(dynsym_data, &offset)) 1007 break; 1008 1009 if (symbol.d_tag != DT_NEEDED) 1010 continue; 1011 1012 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 1013 const char *lib_name = dynstr_data.PeekCStr(str_index); 1014 m_filespec_ap->Append(FileSpec(lib_name, true)); 1015 } 1016 } 1017 1018 return m_filespec_ap->GetSize(); 1019 } 1020 1021 //---------------------------------------------------------------------- 1022 // GetProgramHeaderInfo 1023 //---------------------------------------------------------------------- 1024 size_t 1025 ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers, 1026 DataExtractor &object_data, 1027 const ELFHeader &header) 1028 { 1029 // We have already parsed the program headers 1030 if (!program_headers.empty()) 1031 return program_headers.size(); 1032 1033 // If there are no program headers to read we are done. 1034 if (header.e_phnum == 0) 1035 return 0; 1036 1037 program_headers.resize(header.e_phnum); 1038 if (program_headers.size() != header.e_phnum) 1039 return 0; 1040 1041 const size_t ph_size = header.e_phnum * header.e_phentsize; 1042 const elf_off ph_offset = header.e_phoff; 1043 DataExtractor data; 1044 if (data.SetData(object_data, ph_offset, ph_size) != ph_size) 1045 return 0; 1046 1047 uint32_t idx; 1048 lldb::offset_t offset; 1049 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) 1050 { 1051 if (program_headers[idx].Parse(data, &offset) == false) 1052 break; 1053 } 1054 1055 if (idx < program_headers.size()) 1056 program_headers.resize(idx); 1057 1058 return program_headers.size(); 1059 1060 } 1061 1062 //---------------------------------------------------------------------- 1063 // ParseProgramHeaders 1064 //---------------------------------------------------------------------- 1065 size_t 1066 ObjectFileELF::ParseProgramHeaders() 1067 { 1068 return GetProgramHeaderInfo(m_program_headers, m_data, m_header); 1069 } 1070 1071 lldb_private::Error 1072 ObjectFileELF::RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid) 1073 { 1074 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1075 Error error; 1076 1077 lldb::offset_t offset = 0; 1078 1079 while (true) 1080 { 1081 // Parse the note header. If this fails, bail out. 1082 ELFNote note = ELFNote(); 1083 if (!note.Parse(data, &offset)) 1084 { 1085 // We're done. 1086 return error; 1087 } 1088 1089 // If a tag processor handles the tag, it should set processed to true, and 1090 // the loop will assume the tag processing has moved entirely past the note's payload. 1091 // Otherwise, leave it false and the end of the loop will handle the offset properly. 1092 bool processed = false; 1093 1094 if (log) 1095 log->Printf ("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, __FUNCTION__, note.n_name.c_str (), note.n_type); 1096 1097 // Process FreeBSD ELF notes. 1098 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) && 1099 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) && 1100 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) 1101 { 1102 // We'll consume the payload below. 1103 processed = true; 1104 1105 // Pull out the min version info. 1106 uint32_t version_info; 1107 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1108 { 1109 error.SetErrorString ("failed to read FreeBSD ABI note payload"); 1110 return error; 1111 } 1112 1113 // Convert the version info into a major/minor number. 1114 const uint32_t version_major = version_info / 100000; 1115 const uint32_t version_minor = (version_info / 1000) % 100; 1116 1117 char os_name[32]; 1118 snprintf (os_name, sizeof (os_name), "freebsd%" PRIu32 ".%" PRIu32, version_major, version_minor); 1119 1120 // Set the elf OS version to FreeBSD. Also clear the vendor. 1121 arch_spec.GetTriple ().setOSName (os_name); 1122 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1123 1124 if (log) 1125 log->Printf ("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_major, version_minor, static_cast<uint32_t> (version_info % 1000)); 1126 } 1127 // Process GNU ELF notes. 1128 else if (note.n_name == LLDB_NT_OWNER_GNU) 1129 { 1130 switch (note.n_type) 1131 { 1132 case LLDB_NT_GNU_ABI_TAG: 1133 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) 1134 { 1135 // We'll consume the payload below. 1136 processed = true; 1137 1138 // Pull out the min OS version supporting the ABI. 1139 uint32_t version_info[4]; 1140 if (data.GetU32 (&offset, &version_info[0], note.n_descsz / 4) == nullptr) 1141 { 1142 error.SetErrorString ("failed to read GNU ABI note payload"); 1143 return error; 1144 } 1145 1146 // Set the OS per the OS field. 1147 switch (version_info[0]) 1148 { 1149 case LLDB_NT_GNU_ABI_OS_LINUX: 1150 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Linux); 1151 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1152 if (log) 1153 log->Printf ("ObjectFileELF::%s detected Linux, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1154 // FIXME we have the minimal version number, we could be propagating that. version_info[1] = OS Major, version_info[2] = OS Minor, version_info[3] = Revision. 1155 break; 1156 case LLDB_NT_GNU_ABI_OS_HURD: 1157 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::UnknownOS); 1158 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1159 if (log) 1160 log->Printf ("ObjectFileELF::%s detected Hurd (unsupported), min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1161 break; 1162 case LLDB_NT_GNU_ABI_OS_SOLARIS: 1163 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Solaris); 1164 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1165 if (log) 1166 log->Printf ("ObjectFileELF::%s detected Solaris, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1167 break; 1168 default: 1169 if (log) 1170 log->Printf ("ObjectFileELF::%s unrecognized OS in note, id %" PRIu32 ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[0], version_info[1], version_info[2], version_info[3]); 1171 break; 1172 } 1173 } 1174 break; 1175 1176 case LLDB_NT_GNU_BUILD_ID_TAG: 1177 // Only bother processing this if we don't already have the uuid set. 1178 if (!uuid.IsValid()) 1179 { 1180 // We'll consume the payload below. 1181 processed = true; 1182 1183 // 16 bytes is UUID|MD5, 20 bytes is SHA1 1184 if ((note.n_descsz == 16 || note.n_descsz == 20)) 1185 { 1186 uint8_t uuidbuf[20]; 1187 if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == nullptr) 1188 { 1189 error.SetErrorString ("failed to read GNU_BUILD_ID note payload"); 1190 return error; 1191 } 1192 1193 // Save the build id as the UUID for the module. 1194 uuid.SetBytes (uuidbuf, note.n_descsz); 1195 } 1196 } 1197 break; 1198 } 1199 } 1200 // Process NetBSD ELF notes. 1201 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) && 1202 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) && 1203 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) 1204 { 1205 1206 // We'll consume the payload below. 1207 processed = true; 1208 1209 // Pull out the min version info. 1210 uint32_t version_info; 1211 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1212 { 1213 error.SetErrorString ("failed to read NetBSD ABI note payload"); 1214 return error; 1215 } 1216 1217 // Set the elf OS version to NetBSD. Also clear the vendor. 1218 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::NetBSD); 1219 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1220 1221 if (log) 1222 log->Printf ("ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32, __FUNCTION__, version_info); 1223 } 1224 1225 if (!processed) 1226 offset += llvm::RoundUpToAlignment(note.n_descsz, 4); 1227 } 1228 1229 return error; 1230 } 1231 1232 1233 //---------------------------------------------------------------------- 1234 // GetSectionHeaderInfo 1235 //---------------------------------------------------------------------- 1236 size_t 1237 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1238 lldb_private::DataExtractor &object_data, 1239 const elf::ELFHeader &header, 1240 lldb_private::UUID &uuid, 1241 std::string &gnu_debuglink_file, 1242 uint32_t &gnu_debuglink_crc, 1243 ArchSpec &arch_spec) 1244 { 1245 // Don't reparse the section headers if we already did that. 1246 if (!section_headers.empty()) 1247 return section_headers.size(); 1248 1249 // Only initialize the arch_spec to okay defaults if they're not already set. 1250 // We'll refine this with note data as we parse the notes. 1251 if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS) 1252 { 1253 arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, LLDB_INVALID_CPUTYPE); 1254 arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString()); 1255 arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1256 } 1257 1258 // If there are no section headers we are done. 1259 if (header.e_shnum == 0) 1260 return 0; 1261 1262 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1263 1264 section_headers.resize(header.e_shnum); 1265 if (section_headers.size() != header.e_shnum) 1266 return 0; 1267 1268 const size_t sh_size = header.e_shnum * header.e_shentsize; 1269 const elf_off sh_offset = header.e_shoff; 1270 DataExtractor sh_data; 1271 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 1272 return 0; 1273 1274 uint32_t idx; 1275 lldb::offset_t offset; 1276 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1277 { 1278 if (section_headers[idx].Parse(sh_data, &offset) == false) 1279 break; 1280 } 1281 if (idx < section_headers.size()) 1282 section_headers.resize(idx); 1283 1284 const unsigned strtab_idx = header.e_shstrndx; 1285 if (strtab_idx && strtab_idx < section_headers.size()) 1286 { 1287 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1288 const size_t byte_size = sheader.sh_size; 1289 const Elf64_Off offset = sheader.sh_offset; 1290 lldb_private::DataExtractor shstr_data; 1291 1292 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 1293 { 1294 for (SectionHeaderCollIter I = section_headers.begin(); 1295 I != section_headers.end(); ++I) 1296 { 1297 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1298 const ELFSectionHeaderInfo &header = *I; 1299 const uint64_t section_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1300 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1301 1302 I->section_name = name; 1303 1304 if (name == g_sect_name_gnu_debuglink) 1305 { 1306 DataExtractor data; 1307 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 1308 { 1309 lldb::offset_t gnu_debuglink_offset = 0; 1310 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1311 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 1312 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1313 } 1314 } 1315 1316 // Process ELF note section entries. 1317 if (header.sh_type == SHT_NOTE) 1318 { 1319 // Allow notes to refine module info. 1320 DataExtractor data; 1321 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 1322 { 1323 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1324 if (error.Fail ()) 1325 { 1326 if (log) 1327 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1328 } 1329 } 1330 } 1331 } 1332 1333 return section_headers.size(); 1334 } 1335 } 1336 1337 section_headers.clear(); 1338 return 0; 1339 } 1340 1341 size_t 1342 ObjectFileELF::GetProgramHeaderCount() 1343 { 1344 return ParseProgramHeaders(); 1345 } 1346 1347 const elf::ELFProgramHeader * 1348 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1349 { 1350 if (!id || !ParseProgramHeaders()) 1351 return NULL; 1352 1353 if (--id < m_program_headers.size()) 1354 return &m_program_headers[id]; 1355 1356 return NULL; 1357 } 1358 1359 DataExtractor 1360 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1361 { 1362 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1363 if (segment_header == NULL) 1364 return DataExtractor(); 1365 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1366 } 1367 1368 //---------------------------------------------------------------------- 1369 // ParseSectionHeaders 1370 //---------------------------------------------------------------------- 1371 size_t 1372 ObjectFileELF::ParseSectionHeaders() 1373 { 1374 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec); 1375 } 1376 1377 const ObjectFileELF::ELFSectionHeaderInfo * 1378 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1379 { 1380 if (!id || !ParseSectionHeaders()) 1381 return NULL; 1382 1383 if (--id < m_section_headers.size()) 1384 return &m_section_headers[id]; 1385 1386 return NULL; 1387 } 1388 1389 void 1390 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1391 { 1392 if (!m_sections_ap.get() && ParseSectionHeaders()) 1393 { 1394 m_sections_ap.reset(new SectionList()); 1395 1396 for (SectionHeaderCollIter I = m_section_headers.begin(); 1397 I != m_section_headers.end(); ++I) 1398 { 1399 const ELFSectionHeaderInfo &header = *I; 1400 1401 ConstString& name = I->section_name; 1402 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1403 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1404 1405 static ConstString g_sect_name_text (".text"); 1406 static ConstString g_sect_name_data (".data"); 1407 static ConstString g_sect_name_bss (".bss"); 1408 static ConstString g_sect_name_tdata (".tdata"); 1409 static ConstString g_sect_name_tbss (".tbss"); 1410 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1411 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1412 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1413 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1414 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1415 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1416 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1417 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1418 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1419 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1420 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1421 static ConstString g_sect_name_eh_frame (".eh_frame"); 1422 1423 SectionType sect_type = eSectionTypeOther; 1424 1425 bool is_thread_specific = false; 1426 1427 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1428 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1429 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1430 else if (name == g_sect_name_tdata) 1431 { 1432 sect_type = eSectionTypeData; 1433 is_thread_specific = true; 1434 } 1435 else if (name == g_sect_name_tbss) 1436 { 1437 sect_type = eSectionTypeZeroFill; 1438 is_thread_specific = true; 1439 } 1440 // .debug_abbrev – Abbreviations used in the .debug_info section 1441 // .debug_aranges – Lookup table for mapping addresses to compilation units 1442 // .debug_frame – Call frame information 1443 // .debug_info – The core DWARF information section 1444 // .debug_line – Line number information 1445 // .debug_loc – Location lists used in DW_AT_location attributes 1446 // .debug_macinfo – Macro information 1447 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1448 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1449 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1450 // .debug_str – String table used in .debug_info 1451 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1452 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1453 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1454 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1455 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1456 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1457 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1458 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1459 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1460 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1461 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1462 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1463 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1464 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1465 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1466 1467 switch (header.sh_type) 1468 { 1469 case SHT_SYMTAB: 1470 assert (sect_type == eSectionTypeOther); 1471 sect_type = eSectionTypeELFSymbolTable; 1472 break; 1473 case SHT_DYNSYM: 1474 assert (sect_type == eSectionTypeOther); 1475 sect_type = eSectionTypeELFDynamicSymbols; 1476 break; 1477 case SHT_RELA: 1478 case SHT_REL: 1479 assert (sect_type == eSectionTypeOther); 1480 sect_type = eSectionTypeELFRelocationEntries; 1481 break; 1482 case SHT_DYNAMIC: 1483 assert (sect_type == eSectionTypeOther); 1484 sect_type = eSectionTypeELFDynamicLinkInfo; 1485 break; 1486 } 1487 1488 elf::elf_xword log2align = (header.sh_addralign==0) 1489 ? 0 1490 : llvm::Log2_64(header.sh_addralign); 1491 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1492 this, // ObjectFile to which this section belongs and should read section data from. 1493 SectionIndex(I), // Section ID. 1494 name, // Section name. 1495 sect_type, // Section type. 1496 header.sh_addr, // VM address. 1497 vm_size, // VM size in bytes of this section. 1498 header.sh_offset, // Offset of this section in the file. 1499 file_size, // Size of the section as found in the file. 1500 log2align, // Alignment of the section 1501 header.sh_flags)); // Flags for this section. 1502 1503 if (is_thread_specific) 1504 section_sp->SetIsThreadSpecific (is_thread_specific); 1505 m_sections_ap->AddSection(section_sp); 1506 } 1507 } 1508 1509 if (m_sections_ap.get()) 1510 { 1511 if (GetType() == eTypeDebugInfo) 1512 { 1513 static const SectionType g_sections[] = 1514 { 1515 eSectionTypeDWARFDebugAranges, 1516 eSectionTypeDWARFDebugInfo, 1517 eSectionTypeDWARFDebugAbbrev, 1518 eSectionTypeDWARFDebugFrame, 1519 eSectionTypeDWARFDebugLine, 1520 eSectionTypeDWARFDebugStr, 1521 eSectionTypeDWARFDebugLoc, 1522 eSectionTypeDWARFDebugMacInfo, 1523 eSectionTypeDWARFDebugPubNames, 1524 eSectionTypeDWARFDebugPubTypes, 1525 eSectionTypeDWARFDebugRanges, 1526 eSectionTypeELFSymbolTable, 1527 }; 1528 SectionList *elf_section_list = m_sections_ap.get(); 1529 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1530 { 1531 SectionType section_type = g_sections[idx]; 1532 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1533 if (section_sp) 1534 { 1535 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1536 if (module_section_sp) 1537 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1538 else 1539 unified_section_list.AddSection (section_sp); 1540 } 1541 } 1542 } 1543 else 1544 { 1545 unified_section_list = *m_sections_ap; 1546 } 1547 } 1548 } 1549 1550 // private 1551 unsigned 1552 ObjectFileELF::ParseSymbols (Symtab *symtab, 1553 user_id_t start_id, 1554 SectionList *section_list, 1555 const size_t num_symbols, 1556 const DataExtractor &symtab_data, 1557 const DataExtractor &strtab_data) 1558 { 1559 ELFSymbol symbol; 1560 lldb::offset_t offset = 0; 1561 1562 static ConstString text_section_name(".text"); 1563 static ConstString init_section_name(".init"); 1564 static ConstString fini_section_name(".fini"); 1565 static ConstString ctors_section_name(".ctors"); 1566 static ConstString dtors_section_name(".dtors"); 1567 1568 static ConstString data_section_name(".data"); 1569 static ConstString rodata_section_name(".rodata"); 1570 static ConstString rodata1_section_name(".rodata1"); 1571 static ConstString data2_section_name(".data1"); 1572 static ConstString bss_section_name(".bss"); 1573 1574 //StreamFile strm(stdout, false); 1575 unsigned i; 1576 for (i = 0; i < num_symbols; ++i) 1577 { 1578 if (symbol.Parse(symtab_data, &offset) == false) 1579 break; 1580 1581 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1582 1583 // No need to add non-section symbols that have no names 1584 if (symbol.getType() != STT_SECTION && 1585 (symbol_name == NULL || symbol_name[0] == '\0')) 1586 continue; 1587 1588 //symbol.Dump (&strm, i, &strtab_data, section_list); 1589 1590 SectionSP symbol_section_sp; 1591 SymbolType symbol_type = eSymbolTypeInvalid; 1592 Elf64_Half symbol_idx = symbol.st_shndx; 1593 1594 switch (symbol_idx) 1595 { 1596 case SHN_ABS: 1597 symbol_type = eSymbolTypeAbsolute; 1598 break; 1599 case SHN_UNDEF: 1600 symbol_type = eSymbolTypeUndefined; 1601 break; 1602 default: 1603 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 1604 break; 1605 } 1606 1607 // If a symbol is undefined do not process it further even if it has a STT type 1608 if (symbol_type != eSymbolTypeUndefined) 1609 { 1610 switch (symbol.getType()) 1611 { 1612 default: 1613 case STT_NOTYPE: 1614 // The symbol's type is not specified. 1615 break; 1616 1617 case STT_OBJECT: 1618 // The symbol is associated with a data object, such as a variable, 1619 // an array, etc. 1620 symbol_type = eSymbolTypeData; 1621 break; 1622 1623 case STT_FUNC: 1624 // The symbol is associated with a function or other executable code. 1625 symbol_type = eSymbolTypeCode; 1626 break; 1627 1628 case STT_SECTION: 1629 // The symbol is associated with a section. Symbol table entries of 1630 // this type exist primarily for relocation and normally have 1631 // STB_LOCAL binding. 1632 break; 1633 1634 case STT_FILE: 1635 // Conventionally, the symbol's name gives the name of the source 1636 // file associated with the object file. A file symbol has STB_LOCAL 1637 // binding, its section index is SHN_ABS, and it precedes the other 1638 // STB_LOCAL symbols for the file, if it is present. 1639 symbol_type = eSymbolTypeSourceFile; 1640 break; 1641 1642 case STT_GNU_IFUNC: 1643 // The symbol is associated with an indirect function. The actual 1644 // function will be resolved if it is referenced. 1645 symbol_type = eSymbolTypeResolver; 1646 break; 1647 } 1648 } 1649 1650 if (symbol_type == eSymbolTypeInvalid) 1651 { 1652 if (symbol_section_sp) 1653 { 1654 const ConstString §_name = symbol_section_sp->GetName(); 1655 if (sect_name == text_section_name || 1656 sect_name == init_section_name || 1657 sect_name == fini_section_name || 1658 sect_name == ctors_section_name || 1659 sect_name == dtors_section_name) 1660 { 1661 symbol_type = eSymbolTypeCode; 1662 } 1663 else if (sect_name == data_section_name || 1664 sect_name == data2_section_name || 1665 sect_name == rodata_section_name || 1666 sect_name == rodata1_section_name || 1667 sect_name == bss_section_name) 1668 { 1669 symbol_type = eSymbolTypeData; 1670 } 1671 } 1672 } 1673 1674 // If the symbol section we've found has no data (SHT_NOBITS), then check the module section 1675 // list. This can happen if we're parsing the debug file and it has no .text section, for example. 1676 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1677 { 1678 ModuleSP module_sp(GetModule()); 1679 if (module_sp) 1680 { 1681 SectionList *module_section_list = module_sp->GetSectionList(); 1682 if (module_section_list && module_section_list != section_list) 1683 { 1684 const ConstString §_name = symbol_section_sp->GetName(); 1685 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1686 if (section_sp && section_sp->GetFileSize()) 1687 { 1688 symbol_section_sp = section_sp; 1689 } 1690 } 1691 } 1692 } 1693 1694 uint64_t symbol_value = symbol.st_value; 1695 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 1696 symbol_value -= symbol_section_sp->GetFileAddress(); 1697 bool is_global = symbol.getBinding() == STB_GLOBAL; 1698 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1699 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1700 Symbol dc_symbol( 1701 i + start_id, // ID is the original symbol table index. 1702 symbol_name, // Symbol name. 1703 is_mangled, // Is the symbol name mangled? 1704 symbol_type, // Type of this symbol 1705 is_global, // Is this globally visible? 1706 false, // Is this symbol debug info? 1707 false, // Is this symbol a trampoline? 1708 false, // Is this symbol artificial? 1709 symbol_section_sp, // Section in which this symbol is defined or null. 1710 symbol_value, // Offset in section or symbol value. 1711 symbol.st_size, // Size in bytes of this symbol. 1712 true, // Size is valid 1713 flags); // Symbol flags. 1714 symtab->AddSymbol(dc_symbol); 1715 } 1716 1717 return i; 1718 } 1719 1720 unsigned 1721 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 1722 { 1723 if (symtab->GetObjectFile() != this) 1724 { 1725 // If the symbol table section is owned by a different object file, have it do the 1726 // parsing. 1727 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 1728 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 1729 } 1730 1731 // Get section list for this object file. 1732 SectionList *section_list = m_sections_ap.get(); 1733 if (!section_list) 1734 return 0; 1735 1736 user_id_t symtab_id = symtab->GetID(); 1737 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 1738 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1739 symtab_hdr->sh_type == SHT_DYNSYM); 1740 1741 // sh_link: section header index of associated string table. 1742 // Section ID's are ones based. 1743 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1744 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1745 1746 if (symtab && strtab) 1747 { 1748 assert (symtab->GetObjectFile() == this); 1749 assert (strtab->GetObjectFile() == this); 1750 1751 DataExtractor symtab_data; 1752 DataExtractor strtab_data; 1753 if (ReadSectionData(symtab, symtab_data) && 1754 ReadSectionData(strtab, strtab_data)) 1755 { 1756 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 1757 1758 return ParseSymbols(symbol_table, start_id, section_list, 1759 num_symbols, symtab_data, strtab_data); 1760 } 1761 } 1762 1763 return 0; 1764 } 1765 1766 size_t 1767 ObjectFileELF::ParseDynamicSymbols() 1768 { 1769 if (m_dynamic_symbols.size()) 1770 return m_dynamic_symbols.size(); 1771 1772 SectionList *section_list = GetSectionList(); 1773 if (!section_list) 1774 return 0; 1775 1776 // Find the SHT_DYNAMIC section. 1777 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1778 if (!dynsym) 1779 return 0; 1780 assert (dynsym->GetObjectFile() == this); 1781 1782 ELFDynamic symbol; 1783 DataExtractor dynsym_data; 1784 if (ReadSectionData(dynsym, dynsym_data)) 1785 { 1786 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1787 lldb::offset_t cursor = 0; 1788 1789 while (cursor < section_size) 1790 { 1791 if (!symbol.Parse(dynsym_data, &cursor)) 1792 break; 1793 1794 m_dynamic_symbols.push_back(symbol); 1795 } 1796 } 1797 1798 return m_dynamic_symbols.size(); 1799 } 1800 1801 const ELFDynamic * 1802 ObjectFileELF::FindDynamicSymbol(unsigned tag) 1803 { 1804 if (!ParseDynamicSymbols()) 1805 return NULL; 1806 1807 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1808 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1809 for ( ; I != E; ++I) 1810 { 1811 ELFDynamic *symbol = &*I; 1812 1813 if (symbol->d_tag == tag) 1814 return symbol; 1815 } 1816 1817 return NULL; 1818 } 1819 1820 unsigned 1821 ObjectFileELF::PLTRelocationType() 1822 { 1823 // DT_PLTREL 1824 // This member specifies the type of relocation entry to which the 1825 // procedure linkage table refers. The d_val member holds DT_REL or 1826 // DT_RELA, as appropriate. All relocations in a procedure linkage table 1827 // must use the same relocation. 1828 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1829 1830 if (symbol) 1831 return symbol->d_val; 1832 1833 return 0; 1834 } 1835 1836 static unsigned 1837 ParsePLTRelocations(Symtab *symbol_table, 1838 user_id_t start_id, 1839 unsigned rel_type, 1840 const ELFHeader *hdr, 1841 const ELFSectionHeader *rel_hdr, 1842 const ELFSectionHeader *plt_hdr, 1843 const ELFSectionHeader *sym_hdr, 1844 const lldb::SectionSP &plt_section_sp, 1845 DataExtractor &rel_data, 1846 DataExtractor &symtab_data, 1847 DataExtractor &strtab_data) 1848 { 1849 ELFRelocation rel(rel_type); 1850 ELFSymbol symbol; 1851 lldb::offset_t offset = 0; 1852 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 1853 // So round the entsize up by the alignment if addralign is set. 1854 const elf_xword plt_entsize = plt_hdr->sh_addralign ? 1855 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 1856 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1857 1858 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1859 reloc_info_fn reloc_type; 1860 reloc_info_fn reloc_symbol; 1861 1862 if (hdr->Is32Bit()) 1863 { 1864 reloc_type = ELFRelocation::RelocType32; 1865 reloc_symbol = ELFRelocation::RelocSymbol32; 1866 } 1867 else 1868 { 1869 reloc_type = ELFRelocation::RelocType64; 1870 reloc_symbol = ELFRelocation::RelocSymbol64; 1871 } 1872 1873 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1874 unsigned i; 1875 for (i = 0; i < num_relocations; ++i) 1876 { 1877 if (rel.Parse(rel_data, &offset) == false) 1878 break; 1879 1880 if (reloc_type(rel) != slot_type) 1881 continue; 1882 1883 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1884 uint64_t plt_index = (i + 1) * plt_entsize; 1885 1886 if (!symbol.Parse(symtab_data, &symbol_offset)) 1887 break; 1888 1889 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1890 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1891 1892 Symbol jump_symbol( 1893 i + start_id, // Symbol table index 1894 symbol_name, // symbol name. 1895 is_mangled, // is the symbol name mangled? 1896 eSymbolTypeTrampoline, // Type of this symbol 1897 false, // Is this globally visible? 1898 false, // Is this symbol debug info? 1899 true, // Is this symbol a trampoline? 1900 true, // Is this symbol artificial? 1901 plt_section_sp, // Section in which this symbol is defined or null. 1902 plt_index, // Offset in section or symbol value. 1903 plt_entsize, // Size in bytes of this symbol. 1904 true, // Size is valid 1905 0); // Symbol flags. 1906 1907 symbol_table->AddSymbol(jump_symbol); 1908 } 1909 1910 return i; 1911 } 1912 1913 unsigned 1914 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 1915 user_id_t start_id, 1916 const ELFSectionHeaderInfo *rel_hdr, 1917 user_id_t rel_id) 1918 { 1919 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 1920 1921 // The link field points to the associated symbol table. The info field 1922 // points to the section holding the plt. 1923 user_id_t symtab_id = rel_hdr->sh_link; 1924 user_id_t plt_id = rel_hdr->sh_info; 1925 1926 if (!symtab_id || !plt_id) 1927 return 0; 1928 1929 // Section ID's are ones based; 1930 symtab_id++; 1931 plt_id++; 1932 1933 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 1934 if (!plt_hdr) 1935 return 0; 1936 1937 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 1938 if (!sym_hdr) 1939 return 0; 1940 1941 SectionList *section_list = m_sections_ap.get(); 1942 if (!section_list) 1943 return 0; 1944 1945 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 1946 if (!rel_section) 1947 return 0; 1948 1949 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 1950 if (!plt_section_sp) 1951 return 0; 1952 1953 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1954 if (!symtab) 1955 return 0; 1956 1957 // sh_link points to associated string table. 1958 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 1959 if (!strtab) 1960 return 0; 1961 1962 DataExtractor rel_data; 1963 if (!ReadSectionData(rel_section, rel_data)) 1964 return 0; 1965 1966 DataExtractor symtab_data; 1967 if (!ReadSectionData(symtab, symtab_data)) 1968 return 0; 1969 1970 DataExtractor strtab_data; 1971 if (!ReadSectionData(strtab, strtab_data)) 1972 return 0; 1973 1974 unsigned rel_type = PLTRelocationType(); 1975 if (!rel_type) 1976 return 0; 1977 1978 return ParsePLTRelocations (symbol_table, 1979 start_id, 1980 rel_type, 1981 &m_header, 1982 rel_hdr, 1983 plt_hdr, 1984 sym_hdr, 1985 plt_section_sp, 1986 rel_data, 1987 symtab_data, 1988 strtab_data); 1989 } 1990 1991 unsigned 1992 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 1993 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 1994 DataExtractor &rel_data, DataExtractor &symtab_data, 1995 DataExtractor &debug_data, Section* rel_section) 1996 { 1997 ELFRelocation rel(rel_hdr->sh_type); 1998 lldb::addr_t offset = 0; 1999 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2000 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2001 reloc_info_fn reloc_type; 2002 reloc_info_fn reloc_symbol; 2003 2004 if (hdr->Is32Bit()) 2005 { 2006 reloc_type = ELFRelocation::RelocType32; 2007 reloc_symbol = ELFRelocation::RelocSymbol32; 2008 } 2009 else 2010 { 2011 reloc_type = ELFRelocation::RelocType64; 2012 reloc_symbol = ELFRelocation::RelocSymbol64; 2013 } 2014 2015 for (unsigned i = 0; i < num_relocations; ++i) 2016 { 2017 if (rel.Parse(rel_data, &offset) == false) 2018 break; 2019 2020 Symbol* symbol = NULL; 2021 2022 if (hdr->Is32Bit()) 2023 { 2024 switch (reloc_type(rel)) { 2025 case R_386_32: 2026 case R_386_PC32: 2027 default: 2028 assert(false && "unexpected relocation type"); 2029 } 2030 } else { 2031 switch (reloc_type(rel)) { 2032 case R_X86_64_64: 2033 { 2034 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2035 if (symbol) 2036 { 2037 addr_t value = symbol->GetAddress().GetFileAddress(); 2038 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2039 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2040 *dst = value + ELFRelocation::RelocAddend64(rel); 2041 } 2042 break; 2043 } 2044 case R_X86_64_32: 2045 case R_X86_64_32S: 2046 { 2047 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2048 if (symbol) 2049 { 2050 addr_t value = symbol->GetAddress().GetFileAddress(); 2051 value += ELFRelocation::RelocAddend32(rel); 2052 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2053 (reloc_type(rel) == R_X86_64_32S && 2054 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2055 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2056 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2057 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2058 *dst = truncated_addr; 2059 } 2060 break; 2061 } 2062 case R_X86_64_PC32: 2063 default: 2064 assert(false && "unexpected relocation type"); 2065 } 2066 } 2067 } 2068 2069 return 0; 2070 } 2071 2072 unsigned 2073 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2074 { 2075 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2076 2077 // Parse in the section list if needed. 2078 SectionList *section_list = GetSectionList(); 2079 if (!section_list) 2080 return 0; 2081 2082 // Section ID's are ones based. 2083 user_id_t symtab_id = rel_hdr->sh_link + 1; 2084 user_id_t debug_id = rel_hdr->sh_info + 1; 2085 2086 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2087 if (!symtab_hdr) 2088 return 0; 2089 2090 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2091 if (!debug_hdr) 2092 return 0; 2093 2094 Section *rel = section_list->FindSectionByID(rel_id).get(); 2095 if (!rel) 2096 return 0; 2097 2098 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2099 if (!symtab) 2100 return 0; 2101 2102 Section *debug = section_list->FindSectionByID(debug_id).get(); 2103 if (!debug) 2104 return 0; 2105 2106 DataExtractor rel_data; 2107 DataExtractor symtab_data; 2108 DataExtractor debug_data; 2109 2110 if (ReadSectionData(rel, rel_data) && 2111 ReadSectionData(symtab, symtab_data) && 2112 ReadSectionData(debug, debug_data)) 2113 { 2114 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2115 rel_data, symtab_data, debug_data, debug); 2116 } 2117 2118 return 0; 2119 } 2120 2121 Symtab * 2122 ObjectFileELF::GetSymtab() 2123 { 2124 ModuleSP module_sp(GetModule()); 2125 if (!module_sp) 2126 return NULL; 2127 2128 // We always want to use the main object file so we (hopefully) only have one cached copy 2129 // of our symtab, dynamic sections, etc. 2130 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2131 if (module_obj_file && module_obj_file != this) 2132 return module_obj_file->GetSymtab(); 2133 2134 if (m_symtab_ap.get() == NULL) 2135 { 2136 SectionList *section_list = GetSectionList(); 2137 if (!section_list) 2138 return NULL; 2139 2140 uint64_t symbol_id = 0; 2141 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2142 2143 m_symtab_ap.reset(new Symtab(this)); 2144 2145 // Sharable objects and dynamic executables usually have 2 distinct symbol 2146 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2147 // version of the symtab that only contains global symbols. The information found 2148 // in the dynsym is therefore also found in the symtab, while the reverse is not 2149 // necessarily true. 2150 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2151 if (!symtab) 2152 { 2153 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2154 // then use the dynsym section which should always be there. 2155 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2156 } 2157 if (symtab) 2158 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2159 2160 // DT_JMPREL 2161 // If present, this entry's d_ptr member holds the address of relocation 2162 // entries associated solely with the procedure linkage table. Separating 2163 // these relocation entries lets the dynamic linker ignore them during 2164 // process initialization, if lazy binding is enabled. If this entry is 2165 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2166 // also be present. 2167 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2168 if (symbol) 2169 { 2170 // Synthesize trampoline symbols to help navigate the PLT. 2171 addr_t addr = symbol->d_ptr; 2172 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2173 if (reloc_section) 2174 { 2175 user_id_t reloc_id = reloc_section->GetID(); 2176 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2177 assert(reloc_header); 2178 2179 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2180 } 2181 } 2182 } 2183 2184 for (SectionHeaderCollIter I = m_section_headers.begin(); 2185 I != m_section_headers.end(); ++I) 2186 { 2187 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2188 { 2189 if (CalculateType() == eTypeObjectFile) 2190 { 2191 const char *section_name = I->section_name.AsCString(""); 2192 if (strstr(section_name, ".rela.debug") || 2193 strstr(section_name, ".rel.debug")) 2194 { 2195 const ELFSectionHeader &reloc_header = *I; 2196 user_id_t reloc_id = SectionIndex(I); 2197 RelocateDebugSections(&reloc_header, reloc_id); 2198 } 2199 } 2200 } 2201 } 2202 return m_symtab_ap.get(); 2203 } 2204 2205 Symbol * 2206 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2207 { 2208 if (!m_symtab_ap.get()) 2209 return nullptr; // GetSymtab() should be called first. 2210 2211 const SectionList *section_list = GetSectionList(); 2212 if (!section_list) 2213 return nullptr; 2214 2215 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2216 { 2217 AddressRange range; 2218 if (eh_frame->GetAddressRange (so_addr, range)) 2219 { 2220 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2221 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2222 if (symbol) 2223 return symbol; 2224 2225 // Note that a (stripped) symbol won't be found by GetSymtab()... 2226 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2227 if (eh_sym_section_sp.get()) 2228 { 2229 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2230 addr_t offset = file_addr - section_base; 2231 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2232 2233 Symbol eh_symbol( 2234 symbol_id, // Symbol table index. 2235 "???", // Symbol name. 2236 false, // Is the symbol name mangled? 2237 eSymbolTypeCode, // Type of this symbol. 2238 true, // Is this globally visible? 2239 false, // Is this symbol debug info? 2240 false, // Is this symbol a trampoline? 2241 true, // Is this symbol artificial? 2242 eh_sym_section_sp, // Section in which this symbol is defined or null. 2243 offset, // Offset in section or symbol value. 2244 range.GetByteSize(), // Size in bytes of this symbol. 2245 true, // Size is valid. 2246 0); // Symbol flags. 2247 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2248 return m_symtab_ap->SymbolAtIndex(symbol_id); 2249 } 2250 } 2251 } 2252 return nullptr; 2253 } 2254 2255 2256 bool 2257 ObjectFileELF::IsStripped () 2258 { 2259 // TODO: determine this for ELF 2260 return false; 2261 } 2262 2263 //===----------------------------------------------------------------------===// 2264 // Dump 2265 // 2266 // Dump the specifics of the runtime file container (such as any headers 2267 // segments, sections, etc). 2268 //---------------------------------------------------------------------- 2269 void 2270 ObjectFileELF::Dump(Stream *s) 2271 { 2272 DumpELFHeader(s, m_header); 2273 s->EOL(); 2274 DumpELFProgramHeaders(s); 2275 s->EOL(); 2276 DumpELFSectionHeaders(s); 2277 s->EOL(); 2278 SectionList *section_list = GetSectionList(); 2279 if (section_list) 2280 section_list->Dump(s, NULL, true, UINT32_MAX); 2281 Symtab *symtab = GetSymtab(); 2282 if (symtab) 2283 symtab->Dump(s, NULL, eSortOrderNone); 2284 s->EOL(); 2285 DumpDependentModules(s); 2286 s->EOL(); 2287 } 2288 2289 //---------------------------------------------------------------------- 2290 // DumpELFHeader 2291 // 2292 // Dump the ELF header to the specified output stream 2293 //---------------------------------------------------------------------- 2294 void 2295 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2296 { 2297 s->PutCString("ELF Header\n"); 2298 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2299 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2300 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2301 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2302 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2303 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2304 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2305 2306 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2307 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2308 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2309 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2310 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2311 2312 s->Printf("e_type = 0x%4.4x ", header.e_type); 2313 DumpELFHeader_e_type(s, header.e_type); 2314 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2315 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2316 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2317 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2318 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2319 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2320 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2321 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2322 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2323 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2324 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2325 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2326 } 2327 2328 //---------------------------------------------------------------------- 2329 // DumpELFHeader_e_type 2330 // 2331 // Dump an token value for the ELF header member e_type 2332 //---------------------------------------------------------------------- 2333 void 2334 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2335 { 2336 switch (e_type) 2337 { 2338 case ET_NONE: *s << "ET_NONE"; break; 2339 case ET_REL: *s << "ET_REL"; break; 2340 case ET_EXEC: *s << "ET_EXEC"; break; 2341 case ET_DYN: *s << "ET_DYN"; break; 2342 case ET_CORE: *s << "ET_CORE"; break; 2343 default: 2344 break; 2345 } 2346 } 2347 2348 //---------------------------------------------------------------------- 2349 // DumpELFHeader_e_ident_EI_DATA 2350 // 2351 // Dump an token value for the ELF header member e_ident[EI_DATA] 2352 //---------------------------------------------------------------------- 2353 void 2354 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2355 { 2356 switch (ei_data) 2357 { 2358 case ELFDATANONE: *s << "ELFDATANONE"; break; 2359 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2360 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2361 default: 2362 break; 2363 } 2364 } 2365 2366 2367 //---------------------------------------------------------------------- 2368 // DumpELFProgramHeader 2369 // 2370 // Dump a single ELF program header to the specified output stream 2371 //---------------------------------------------------------------------- 2372 void 2373 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 2374 { 2375 DumpELFProgramHeader_p_type(s, ph.p_type); 2376 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 2377 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 2378 2379 DumpELFProgramHeader_p_flags(s, ph.p_flags); 2380 s->Printf(") %8.8" PRIx64, ph.p_align); 2381 } 2382 2383 //---------------------------------------------------------------------- 2384 // DumpELFProgramHeader_p_type 2385 // 2386 // Dump an token value for the ELF program header member p_type which 2387 // describes the type of the program header 2388 // ---------------------------------------------------------------------- 2389 void 2390 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 2391 { 2392 const int kStrWidth = 15; 2393 switch (p_type) 2394 { 2395 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 2396 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 2397 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 2398 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 2399 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 2400 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 2401 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 2402 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 2403 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 2404 default: 2405 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 2406 break; 2407 } 2408 } 2409 2410 2411 //---------------------------------------------------------------------- 2412 // DumpELFProgramHeader_p_flags 2413 // 2414 // Dump an token value for the ELF program header member p_flags 2415 //---------------------------------------------------------------------- 2416 void 2417 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 2418 { 2419 *s << ((p_flags & PF_X) ? "PF_X" : " ") 2420 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 2421 << ((p_flags & PF_W) ? "PF_W" : " ") 2422 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 2423 << ((p_flags & PF_R) ? "PF_R" : " "); 2424 } 2425 2426 //---------------------------------------------------------------------- 2427 // DumpELFProgramHeaders 2428 // 2429 // Dump all of the ELF program header to the specified output stream 2430 //---------------------------------------------------------------------- 2431 void 2432 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 2433 { 2434 if (ParseProgramHeaders()) 2435 { 2436 s->PutCString("Program Headers\n"); 2437 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 2438 "p_filesz p_memsz p_flags p_align\n"); 2439 s->PutCString("==== --------------- -------- -------- -------- " 2440 "-------- -------- ------------------------- --------\n"); 2441 2442 uint32_t idx = 0; 2443 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 2444 I != m_program_headers.end(); ++I, ++idx) 2445 { 2446 s->Printf("[%2u] ", idx); 2447 ObjectFileELF::DumpELFProgramHeader(s, *I); 2448 s->EOL(); 2449 } 2450 } 2451 } 2452 2453 //---------------------------------------------------------------------- 2454 // DumpELFSectionHeader 2455 // 2456 // Dump a single ELF section header to the specified output stream 2457 //---------------------------------------------------------------------- 2458 void 2459 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 2460 { 2461 s->Printf("%8.8x ", sh.sh_name); 2462 DumpELFSectionHeader_sh_type(s, sh.sh_type); 2463 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 2464 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 2465 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 2466 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 2467 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 2468 } 2469 2470 //---------------------------------------------------------------------- 2471 // DumpELFSectionHeader_sh_type 2472 // 2473 // Dump an token value for the ELF section header member sh_type which 2474 // describes the type of the section 2475 //---------------------------------------------------------------------- 2476 void 2477 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 2478 { 2479 const int kStrWidth = 12; 2480 switch (sh_type) 2481 { 2482 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 2483 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 2484 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 2485 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 2486 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 2487 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 2488 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 2489 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 2490 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 2491 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 2492 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 2493 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 2494 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 2495 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 2496 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 2497 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 2498 default: 2499 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 2500 break; 2501 } 2502 } 2503 2504 //---------------------------------------------------------------------- 2505 // DumpELFSectionHeader_sh_flags 2506 // 2507 // Dump an token value for the ELF section header member sh_flags 2508 //---------------------------------------------------------------------- 2509 void 2510 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 2511 { 2512 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 2513 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 2514 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 2515 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 2516 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 2517 } 2518 2519 //---------------------------------------------------------------------- 2520 // DumpELFSectionHeaders 2521 // 2522 // Dump all of the ELF section header to the specified output stream 2523 //---------------------------------------------------------------------- 2524 void 2525 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 2526 { 2527 if (!ParseSectionHeaders()) 2528 return; 2529 2530 s->PutCString("Section Headers\n"); 2531 s->PutCString("IDX name type flags " 2532 "addr offset size link info addralgn " 2533 "entsize Name\n"); 2534 s->PutCString("==== -------- ------------ -------------------------------- " 2535 "-------- -------- -------- -------- -------- -------- " 2536 "-------- ====================\n"); 2537 2538 uint32_t idx = 0; 2539 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 2540 I != m_section_headers.end(); ++I, ++idx) 2541 { 2542 s->Printf("[%2u] ", idx); 2543 ObjectFileELF::DumpELFSectionHeader(s, *I); 2544 const char* section_name = I->section_name.AsCString(""); 2545 if (section_name) 2546 *s << ' ' << section_name << "\n"; 2547 } 2548 } 2549 2550 void 2551 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 2552 { 2553 size_t num_modules = ParseDependentModules(); 2554 2555 if (num_modules > 0) 2556 { 2557 s->PutCString("Dependent Modules:\n"); 2558 for (unsigned i = 0; i < num_modules; ++i) 2559 { 2560 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 2561 s->Printf(" %s\n", spec.GetFilename().GetCString()); 2562 } 2563 } 2564 } 2565 2566 bool 2567 ObjectFileELF::GetArchitecture (ArchSpec &arch) 2568 { 2569 if (!ParseHeader()) 2570 return false; 2571 2572 if (m_section_headers.empty()) 2573 { 2574 // Allow elf notes to be parsed which may affect the detected architecture. 2575 ParseSectionHeaders(); 2576 } 2577 2578 arch = m_arch_spec; 2579 return true; 2580 } 2581 2582 ObjectFile::Type 2583 ObjectFileELF::CalculateType() 2584 { 2585 switch (m_header.e_type) 2586 { 2587 case llvm::ELF::ET_NONE: 2588 // 0 - No file type 2589 return eTypeUnknown; 2590 2591 case llvm::ELF::ET_REL: 2592 // 1 - Relocatable file 2593 return eTypeObjectFile; 2594 2595 case llvm::ELF::ET_EXEC: 2596 // 2 - Executable file 2597 return eTypeExecutable; 2598 2599 case llvm::ELF::ET_DYN: 2600 // 3 - Shared object file 2601 return eTypeSharedLibrary; 2602 2603 case ET_CORE: 2604 // 4 - Core file 2605 return eTypeCoreFile; 2606 2607 default: 2608 break; 2609 } 2610 return eTypeUnknown; 2611 } 2612 2613 ObjectFile::Strata 2614 ObjectFileELF::CalculateStrata() 2615 { 2616 switch (m_header.e_type) 2617 { 2618 case llvm::ELF::ET_NONE: 2619 // 0 - No file type 2620 return eStrataUnknown; 2621 2622 case llvm::ELF::ET_REL: 2623 // 1 - Relocatable file 2624 return eStrataUnknown; 2625 2626 case llvm::ELF::ET_EXEC: 2627 // 2 - Executable file 2628 // TODO: is there any way to detect that an executable is a kernel 2629 // related executable by inspecting the program headers, section 2630 // headers, symbols, or any other flag bits??? 2631 return eStrataUser; 2632 2633 case llvm::ELF::ET_DYN: 2634 // 3 - Shared object file 2635 // TODO: is there any way to detect that an shared library is a kernel 2636 // related executable by inspecting the program headers, section 2637 // headers, symbols, or any other flag bits??? 2638 return eStrataUnknown; 2639 2640 case ET_CORE: 2641 // 4 - Core file 2642 // TODO: is there any way to detect that an core file is a kernel 2643 // related executable by inspecting the program headers, section 2644 // headers, symbols, or any other flag bits??? 2645 return eStrataUnknown; 2646 2647 default: 2648 break; 2649 } 2650 return eStrataUnknown; 2651 } 2652 2653