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 switch (arch_spec.GetAddressByteSize()) 1255 { 1256 case 4: 1257 { 1258 const ArchSpec host_arch32 = Host::GetArchitecture (Host::eSystemDefaultArchitecture32); 1259 if (host_arch32.GetCore() == arch_spec.GetCore()) 1260 { 1261 arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString()); 1262 arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1263 } 1264 } 1265 break; 1266 case 8: 1267 { 1268 const ArchSpec host_arch64 = Host::GetArchitecture (Host::eSystemDefaultArchitecture64); 1269 if (host_arch64.GetCore() == arch_spec.GetCore()) 1270 { 1271 arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString()); 1272 arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString()); 1273 } 1274 } 1275 break; 1276 } 1277 } 1278 1279 // If there are no section headers we are done. 1280 if (header.e_shnum == 0) 1281 return 0; 1282 1283 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1284 1285 section_headers.resize(header.e_shnum); 1286 if (section_headers.size() != header.e_shnum) 1287 return 0; 1288 1289 const size_t sh_size = header.e_shnum * header.e_shentsize; 1290 const elf_off sh_offset = header.e_shoff; 1291 DataExtractor sh_data; 1292 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 1293 return 0; 1294 1295 uint32_t idx; 1296 lldb::offset_t offset; 1297 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1298 { 1299 if (section_headers[idx].Parse(sh_data, &offset) == false) 1300 break; 1301 } 1302 if (idx < section_headers.size()) 1303 section_headers.resize(idx); 1304 1305 const unsigned strtab_idx = header.e_shstrndx; 1306 if (strtab_idx && strtab_idx < section_headers.size()) 1307 { 1308 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1309 const size_t byte_size = sheader.sh_size; 1310 const Elf64_Off offset = sheader.sh_offset; 1311 lldb_private::DataExtractor shstr_data; 1312 1313 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 1314 { 1315 for (SectionHeaderCollIter I = section_headers.begin(); 1316 I != section_headers.end(); ++I) 1317 { 1318 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1319 const ELFSectionHeaderInfo &header = *I; 1320 const uint64_t section_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1321 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1322 1323 I->section_name = name; 1324 1325 if (name == g_sect_name_gnu_debuglink) 1326 { 1327 DataExtractor data; 1328 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 1329 { 1330 lldb::offset_t gnu_debuglink_offset = 0; 1331 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1332 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 1333 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1334 } 1335 } 1336 1337 // Process ELF note section entries. 1338 if (header.sh_type == SHT_NOTE) 1339 { 1340 // Allow notes to refine module info. 1341 DataExtractor data; 1342 if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size)) 1343 { 1344 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1345 if (error.Fail ()) 1346 { 1347 if (log) 1348 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1349 } 1350 } 1351 } 1352 } 1353 1354 return section_headers.size(); 1355 } 1356 } 1357 1358 section_headers.clear(); 1359 return 0; 1360 } 1361 1362 size_t 1363 ObjectFileELF::GetProgramHeaderCount() 1364 { 1365 return ParseProgramHeaders(); 1366 } 1367 1368 const elf::ELFProgramHeader * 1369 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1370 { 1371 if (!id || !ParseProgramHeaders()) 1372 return NULL; 1373 1374 if (--id < m_program_headers.size()) 1375 return &m_program_headers[id]; 1376 1377 return NULL; 1378 } 1379 1380 DataExtractor 1381 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1382 { 1383 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1384 if (segment_header == NULL) 1385 return DataExtractor(); 1386 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1387 } 1388 1389 //---------------------------------------------------------------------- 1390 // ParseSectionHeaders 1391 //---------------------------------------------------------------------- 1392 size_t 1393 ObjectFileELF::ParseSectionHeaders() 1394 { 1395 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec); 1396 } 1397 1398 const ObjectFileELF::ELFSectionHeaderInfo * 1399 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1400 { 1401 if (!id || !ParseSectionHeaders()) 1402 return NULL; 1403 1404 if (--id < m_section_headers.size()) 1405 return &m_section_headers[id]; 1406 1407 return NULL; 1408 } 1409 1410 void 1411 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1412 { 1413 if (!m_sections_ap.get() && ParseSectionHeaders()) 1414 { 1415 m_sections_ap.reset(new SectionList()); 1416 1417 for (SectionHeaderCollIter I = m_section_headers.begin(); 1418 I != m_section_headers.end(); ++I) 1419 { 1420 const ELFSectionHeaderInfo &header = *I; 1421 1422 ConstString& name = I->section_name; 1423 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1424 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1425 1426 static ConstString g_sect_name_text (".text"); 1427 static ConstString g_sect_name_data (".data"); 1428 static ConstString g_sect_name_bss (".bss"); 1429 static ConstString g_sect_name_tdata (".tdata"); 1430 static ConstString g_sect_name_tbss (".tbss"); 1431 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1432 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1433 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1434 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1435 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1436 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1437 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1438 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1439 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1440 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1441 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1442 static ConstString g_sect_name_eh_frame (".eh_frame"); 1443 1444 SectionType sect_type = eSectionTypeOther; 1445 1446 bool is_thread_specific = false; 1447 1448 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1449 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1450 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1451 else if (name == g_sect_name_tdata) 1452 { 1453 sect_type = eSectionTypeData; 1454 is_thread_specific = true; 1455 } 1456 else if (name == g_sect_name_tbss) 1457 { 1458 sect_type = eSectionTypeZeroFill; 1459 is_thread_specific = true; 1460 } 1461 // .debug_abbrev – Abbreviations used in the .debug_info section 1462 // .debug_aranges – Lookup table for mapping addresses to compilation units 1463 // .debug_frame – Call frame information 1464 // .debug_info – The core DWARF information section 1465 // .debug_line – Line number information 1466 // .debug_loc – Location lists used in DW_AT_location attributes 1467 // .debug_macinfo – Macro information 1468 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1469 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1470 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1471 // .debug_str – String table used in .debug_info 1472 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1473 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1474 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1475 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1476 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1477 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1478 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1479 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1480 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1481 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1482 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1483 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1484 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1485 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1486 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1487 1488 switch (header.sh_type) 1489 { 1490 case SHT_SYMTAB: 1491 assert (sect_type == eSectionTypeOther); 1492 sect_type = eSectionTypeELFSymbolTable; 1493 break; 1494 case SHT_DYNSYM: 1495 assert (sect_type == eSectionTypeOther); 1496 sect_type = eSectionTypeELFDynamicSymbols; 1497 break; 1498 case SHT_RELA: 1499 case SHT_REL: 1500 assert (sect_type == eSectionTypeOther); 1501 sect_type = eSectionTypeELFRelocationEntries; 1502 break; 1503 case SHT_DYNAMIC: 1504 assert (sect_type == eSectionTypeOther); 1505 sect_type = eSectionTypeELFDynamicLinkInfo; 1506 break; 1507 } 1508 1509 elf::elf_xword log2align = (header.sh_addralign==0) 1510 ? 0 1511 : llvm::Log2_64(header.sh_addralign); 1512 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1513 this, // ObjectFile to which this section belongs and should read section data from. 1514 SectionIndex(I), // Section ID. 1515 name, // Section name. 1516 sect_type, // Section type. 1517 header.sh_addr, // VM address. 1518 vm_size, // VM size in bytes of this section. 1519 header.sh_offset, // Offset of this section in the file. 1520 file_size, // Size of the section as found in the file. 1521 log2align, // Alignment of the section 1522 header.sh_flags)); // Flags for this section. 1523 1524 if (is_thread_specific) 1525 section_sp->SetIsThreadSpecific (is_thread_specific); 1526 m_sections_ap->AddSection(section_sp); 1527 } 1528 } 1529 1530 if (m_sections_ap.get()) 1531 { 1532 if (GetType() == eTypeDebugInfo) 1533 { 1534 static const SectionType g_sections[] = 1535 { 1536 eSectionTypeDWARFDebugAranges, 1537 eSectionTypeDWARFDebugInfo, 1538 eSectionTypeDWARFDebugAbbrev, 1539 eSectionTypeDWARFDebugFrame, 1540 eSectionTypeDWARFDebugLine, 1541 eSectionTypeDWARFDebugStr, 1542 eSectionTypeDWARFDebugLoc, 1543 eSectionTypeDWARFDebugMacInfo, 1544 eSectionTypeDWARFDebugPubNames, 1545 eSectionTypeDWARFDebugPubTypes, 1546 eSectionTypeDWARFDebugRanges, 1547 eSectionTypeELFSymbolTable, 1548 }; 1549 SectionList *elf_section_list = m_sections_ap.get(); 1550 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1551 { 1552 SectionType section_type = g_sections[idx]; 1553 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1554 if (section_sp) 1555 { 1556 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1557 if (module_section_sp) 1558 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1559 else 1560 unified_section_list.AddSection (section_sp); 1561 } 1562 } 1563 } 1564 else 1565 { 1566 unified_section_list = *m_sections_ap; 1567 } 1568 } 1569 } 1570 1571 // private 1572 unsigned 1573 ObjectFileELF::ParseSymbols (Symtab *symtab, 1574 user_id_t start_id, 1575 SectionList *section_list, 1576 const size_t num_symbols, 1577 const DataExtractor &symtab_data, 1578 const DataExtractor &strtab_data) 1579 { 1580 ELFSymbol symbol; 1581 lldb::offset_t offset = 0; 1582 1583 static ConstString text_section_name(".text"); 1584 static ConstString init_section_name(".init"); 1585 static ConstString fini_section_name(".fini"); 1586 static ConstString ctors_section_name(".ctors"); 1587 static ConstString dtors_section_name(".dtors"); 1588 1589 static ConstString data_section_name(".data"); 1590 static ConstString rodata_section_name(".rodata"); 1591 static ConstString rodata1_section_name(".rodata1"); 1592 static ConstString data2_section_name(".data1"); 1593 static ConstString bss_section_name(".bss"); 1594 1595 //StreamFile strm(stdout, false); 1596 unsigned i; 1597 for (i = 0; i < num_symbols; ++i) 1598 { 1599 if (symbol.Parse(symtab_data, &offset) == false) 1600 break; 1601 1602 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1603 1604 // No need to add non-section symbols that have no names 1605 if (symbol.getType() != STT_SECTION && 1606 (symbol_name == NULL || symbol_name[0] == '\0')) 1607 continue; 1608 1609 //symbol.Dump (&strm, i, &strtab_data, section_list); 1610 1611 SectionSP symbol_section_sp; 1612 SymbolType symbol_type = eSymbolTypeInvalid; 1613 Elf64_Half symbol_idx = symbol.st_shndx; 1614 1615 switch (symbol_idx) 1616 { 1617 case SHN_ABS: 1618 symbol_type = eSymbolTypeAbsolute; 1619 break; 1620 case SHN_UNDEF: 1621 symbol_type = eSymbolTypeUndefined; 1622 break; 1623 default: 1624 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 1625 break; 1626 } 1627 1628 // If a symbol is undefined do not process it further even if it has a STT type 1629 if (symbol_type != eSymbolTypeUndefined) 1630 { 1631 switch (symbol.getType()) 1632 { 1633 default: 1634 case STT_NOTYPE: 1635 // The symbol's type is not specified. 1636 break; 1637 1638 case STT_OBJECT: 1639 // The symbol is associated with a data object, such as a variable, 1640 // an array, etc. 1641 symbol_type = eSymbolTypeData; 1642 break; 1643 1644 case STT_FUNC: 1645 // The symbol is associated with a function or other executable code. 1646 symbol_type = eSymbolTypeCode; 1647 break; 1648 1649 case STT_SECTION: 1650 // The symbol is associated with a section. Symbol table entries of 1651 // this type exist primarily for relocation and normally have 1652 // STB_LOCAL binding. 1653 break; 1654 1655 case STT_FILE: 1656 // Conventionally, the symbol's name gives the name of the source 1657 // file associated with the object file. A file symbol has STB_LOCAL 1658 // binding, its section index is SHN_ABS, and it precedes the other 1659 // STB_LOCAL symbols for the file, if it is present. 1660 symbol_type = eSymbolTypeSourceFile; 1661 break; 1662 1663 case STT_GNU_IFUNC: 1664 // The symbol is associated with an indirect function. The actual 1665 // function will be resolved if it is referenced. 1666 symbol_type = eSymbolTypeResolver; 1667 break; 1668 } 1669 } 1670 1671 if (symbol_type == eSymbolTypeInvalid) 1672 { 1673 if (symbol_section_sp) 1674 { 1675 const ConstString §_name = symbol_section_sp->GetName(); 1676 if (sect_name == text_section_name || 1677 sect_name == init_section_name || 1678 sect_name == fini_section_name || 1679 sect_name == ctors_section_name || 1680 sect_name == dtors_section_name) 1681 { 1682 symbol_type = eSymbolTypeCode; 1683 } 1684 else if (sect_name == data_section_name || 1685 sect_name == data2_section_name || 1686 sect_name == rodata_section_name || 1687 sect_name == rodata1_section_name || 1688 sect_name == bss_section_name) 1689 { 1690 symbol_type = eSymbolTypeData; 1691 } 1692 } 1693 } 1694 1695 // If the symbol section we've found has no data (SHT_NOBITS), then check the module section 1696 // list. This can happen if we're parsing the debug file and it has no .text section, for example. 1697 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1698 { 1699 ModuleSP module_sp(GetModule()); 1700 if (module_sp) 1701 { 1702 SectionList *module_section_list = module_sp->GetSectionList(); 1703 if (module_section_list && module_section_list != section_list) 1704 { 1705 const ConstString §_name = symbol_section_sp->GetName(); 1706 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1707 if (section_sp && section_sp->GetFileSize()) 1708 { 1709 symbol_section_sp = section_sp; 1710 } 1711 } 1712 } 1713 } 1714 1715 uint64_t symbol_value = symbol.st_value; 1716 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 1717 symbol_value -= symbol_section_sp->GetFileAddress(); 1718 bool is_global = symbol.getBinding() == STB_GLOBAL; 1719 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1720 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1721 Symbol dc_symbol( 1722 i + start_id, // ID is the original symbol table index. 1723 symbol_name, // Symbol name. 1724 is_mangled, // Is the symbol name mangled? 1725 symbol_type, // Type of this symbol 1726 is_global, // Is this globally visible? 1727 false, // Is this symbol debug info? 1728 false, // Is this symbol a trampoline? 1729 false, // Is this symbol artificial? 1730 symbol_section_sp, // Section in which this symbol is defined or null. 1731 symbol_value, // Offset in section or symbol value. 1732 symbol.st_size, // Size in bytes of this symbol. 1733 true, // Size is valid 1734 flags); // Symbol flags. 1735 symtab->AddSymbol(dc_symbol); 1736 } 1737 1738 return i; 1739 } 1740 1741 unsigned 1742 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 1743 { 1744 if (symtab->GetObjectFile() != this) 1745 { 1746 // If the symbol table section is owned by a different object file, have it do the 1747 // parsing. 1748 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 1749 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 1750 } 1751 1752 // Get section list for this object file. 1753 SectionList *section_list = m_sections_ap.get(); 1754 if (!section_list) 1755 return 0; 1756 1757 user_id_t symtab_id = symtab->GetID(); 1758 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 1759 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1760 symtab_hdr->sh_type == SHT_DYNSYM); 1761 1762 // sh_link: section header index of associated string table. 1763 // Section ID's are ones based. 1764 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1765 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1766 1767 if (symtab && strtab) 1768 { 1769 assert (symtab->GetObjectFile() == this); 1770 assert (strtab->GetObjectFile() == this); 1771 1772 DataExtractor symtab_data; 1773 DataExtractor strtab_data; 1774 if (ReadSectionData(symtab, symtab_data) && 1775 ReadSectionData(strtab, strtab_data)) 1776 { 1777 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 1778 1779 return ParseSymbols(symbol_table, start_id, section_list, 1780 num_symbols, symtab_data, strtab_data); 1781 } 1782 } 1783 1784 return 0; 1785 } 1786 1787 size_t 1788 ObjectFileELF::ParseDynamicSymbols() 1789 { 1790 if (m_dynamic_symbols.size()) 1791 return m_dynamic_symbols.size(); 1792 1793 SectionList *section_list = GetSectionList(); 1794 if (!section_list) 1795 return 0; 1796 1797 // Find the SHT_DYNAMIC section. 1798 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1799 if (!dynsym) 1800 return 0; 1801 assert (dynsym->GetObjectFile() == this); 1802 1803 ELFDynamic symbol; 1804 DataExtractor dynsym_data; 1805 if (ReadSectionData(dynsym, dynsym_data)) 1806 { 1807 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1808 lldb::offset_t cursor = 0; 1809 1810 while (cursor < section_size) 1811 { 1812 if (!symbol.Parse(dynsym_data, &cursor)) 1813 break; 1814 1815 m_dynamic_symbols.push_back(symbol); 1816 } 1817 } 1818 1819 return m_dynamic_symbols.size(); 1820 } 1821 1822 const ELFDynamic * 1823 ObjectFileELF::FindDynamicSymbol(unsigned tag) 1824 { 1825 if (!ParseDynamicSymbols()) 1826 return NULL; 1827 1828 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1829 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1830 for ( ; I != E; ++I) 1831 { 1832 ELFDynamic *symbol = &*I; 1833 1834 if (symbol->d_tag == tag) 1835 return symbol; 1836 } 1837 1838 return NULL; 1839 } 1840 1841 unsigned 1842 ObjectFileELF::PLTRelocationType() 1843 { 1844 // DT_PLTREL 1845 // This member specifies the type of relocation entry to which the 1846 // procedure linkage table refers. The d_val member holds DT_REL or 1847 // DT_RELA, as appropriate. All relocations in a procedure linkage table 1848 // must use the same relocation. 1849 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1850 1851 if (symbol) 1852 return symbol->d_val; 1853 1854 return 0; 1855 } 1856 1857 static unsigned 1858 ParsePLTRelocations(Symtab *symbol_table, 1859 user_id_t start_id, 1860 unsigned rel_type, 1861 const ELFHeader *hdr, 1862 const ELFSectionHeader *rel_hdr, 1863 const ELFSectionHeader *plt_hdr, 1864 const ELFSectionHeader *sym_hdr, 1865 const lldb::SectionSP &plt_section_sp, 1866 DataExtractor &rel_data, 1867 DataExtractor &symtab_data, 1868 DataExtractor &strtab_data) 1869 { 1870 ELFRelocation rel(rel_type); 1871 ELFSymbol symbol; 1872 lldb::offset_t offset = 0; 1873 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 1874 // So round the entsize up by the alignment if addralign is set. 1875 const elf_xword plt_entsize = plt_hdr->sh_addralign ? 1876 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 1877 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1878 1879 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1880 reloc_info_fn reloc_type; 1881 reloc_info_fn reloc_symbol; 1882 1883 if (hdr->Is32Bit()) 1884 { 1885 reloc_type = ELFRelocation::RelocType32; 1886 reloc_symbol = ELFRelocation::RelocSymbol32; 1887 } 1888 else 1889 { 1890 reloc_type = ELFRelocation::RelocType64; 1891 reloc_symbol = ELFRelocation::RelocSymbol64; 1892 } 1893 1894 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1895 unsigned i; 1896 for (i = 0; i < num_relocations; ++i) 1897 { 1898 if (rel.Parse(rel_data, &offset) == false) 1899 break; 1900 1901 if (reloc_type(rel) != slot_type) 1902 continue; 1903 1904 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1905 uint64_t plt_index = (i + 1) * plt_entsize; 1906 1907 if (!symbol.Parse(symtab_data, &symbol_offset)) 1908 break; 1909 1910 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1911 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1912 1913 Symbol jump_symbol( 1914 i + start_id, // Symbol table index 1915 symbol_name, // symbol name. 1916 is_mangled, // is the symbol name mangled? 1917 eSymbolTypeTrampoline, // Type of this symbol 1918 false, // Is this globally visible? 1919 false, // Is this symbol debug info? 1920 true, // Is this symbol a trampoline? 1921 true, // Is this symbol artificial? 1922 plt_section_sp, // Section in which this symbol is defined or null. 1923 plt_index, // Offset in section or symbol value. 1924 plt_entsize, // Size in bytes of this symbol. 1925 true, // Size is valid 1926 0); // Symbol flags. 1927 1928 symbol_table->AddSymbol(jump_symbol); 1929 } 1930 1931 return i; 1932 } 1933 1934 unsigned 1935 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 1936 user_id_t start_id, 1937 const ELFSectionHeaderInfo *rel_hdr, 1938 user_id_t rel_id) 1939 { 1940 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 1941 1942 // The link field points to the associated symbol table. The info field 1943 // points to the section holding the plt. 1944 user_id_t symtab_id = rel_hdr->sh_link; 1945 user_id_t plt_id = rel_hdr->sh_info; 1946 1947 if (!symtab_id || !plt_id) 1948 return 0; 1949 1950 // Section ID's are ones based; 1951 symtab_id++; 1952 plt_id++; 1953 1954 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 1955 if (!plt_hdr) 1956 return 0; 1957 1958 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 1959 if (!sym_hdr) 1960 return 0; 1961 1962 SectionList *section_list = m_sections_ap.get(); 1963 if (!section_list) 1964 return 0; 1965 1966 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 1967 if (!rel_section) 1968 return 0; 1969 1970 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 1971 if (!plt_section_sp) 1972 return 0; 1973 1974 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 1975 if (!symtab) 1976 return 0; 1977 1978 // sh_link points to associated string table. 1979 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 1980 if (!strtab) 1981 return 0; 1982 1983 DataExtractor rel_data; 1984 if (!ReadSectionData(rel_section, rel_data)) 1985 return 0; 1986 1987 DataExtractor symtab_data; 1988 if (!ReadSectionData(symtab, symtab_data)) 1989 return 0; 1990 1991 DataExtractor strtab_data; 1992 if (!ReadSectionData(strtab, strtab_data)) 1993 return 0; 1994 1995 unsigned rel_type = PLTRelocationType(); 1996 if (!rel_type) 1997 return 0; 1998 1999 return ParsePLTRelocations (symbol_table, 2000 start_id, 2001 rel_type, 2002 &m_header, 2003 rel_hdr, 2004 plt_hdr, 2005 sym_hdr, 2006 plt_section_sp, 2007 rel_data, 2008 symtab_data, 2009 strtab_data); 2010 } 2011 2012 unsigned 2013 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2014 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2015 DataExtractor &rel_data, DataExtractor &symtab_data, 2016 DataExtractor &debug_data, Section* rel_section) 2017 { 2018 ELFRelocation rel(rel_hdr->sh_type); 2019 lldb::addr_t offset = 0; 2020 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2021 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2022 reloc_info_fn reloc_type; 2023 reloc_info_fn reloc_symbol; 2024 2025 if (hdr->Is32Bit()) 2026 { 2027 reloc_type = ELFRelocation::RelocType32; 2028 reloc_symbol = ELFRelocation::RelocSymbol32; 2029 } 2030 else 2031 { 2032 reloc_type = ELFRelocation::RelocType64; 2033 reloc_symbol = ELFRelocation::RelocSymbol64; 2034 } 2035 2036 for (unsigned i = 0; i < num_relocations; ++i) 2037 { 2038 if (rel.Parse(rel_data, &offset) == false) 2039 break; 2040 2041 Symbol* symbol = NULL; 2042 2043 if (hdr->Is32Bit()) 2044 { 2045 switch (reloc_type(rel)) { 2046 case R_386_32: 2047 case R_386_PC32: 2048 default: 2049 assert(false && "unexpected relocation type"); 2050 } 2051 } else { 2052 switch (reloc_type(rel)) { 2053 case R_X86_64_64: 2054 { 2055 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2056 if (symbol) 2057 { 2058 addr_t value = symbol->GetAddress().GetFileAddress(); 2059 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2060 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2061 *dst = value + ELFRelocation::RelocAddend64(rel); 2062 } 2063 break; 2064 } 2065 case R_X86_64_32: 2066 case R_X86_64_32S: 2067 { 2068 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2069 if (symbol) 2070 { 2071 addr_t value = symbol->GetAddress().GetFileAddress(); 2072 value += ELFRelocation::RelocAddend32(rel); 2073 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2074 (reloc_type(rel) == R_X86_64_32S && 2075 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2076 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2077 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2078 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2079 *dst = truncated_addr; 2080 } 2081 break; 2082 } 2083 case R_X86_64_PC32: 2084 default: 2085 assert(false && "unexpected relocation type"); 2086 } 2087 } 2088 } 2089 2090 return 0; 2091 } 2092 2093 unsigned 2094 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2095 { 2096 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2097 2098 // Parse in the section list if needed. 2099 SectionList *section_list = GetSectionList(); 2100 if (!section_list) 2101 return 0; 2102 2103 // Section ID's are ones based. 2104 user_id_t symtab_id = rel_hdr->sh_link + 1; 2105 user_id_t debug_id = rel_hdr->sh_info + 1; 2106 2107 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2108 if (!symtab_hdr) 2109 return 0; 2110 2111 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2112 if (!debug_hdr) 2113 return 0; 2114 2115 Section *rel = section_list->FindSectionByID(rel_id).get(); 2116 if (!rel) 2117 return 0; 2118 2119 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2120 if (!symtab) 2121 return 0; 2122 2123 Section *debug = section_list->FindSectionByID(debug_id).get(); 2124 if (!debug) 2125 return 0; 2126 2127 DataExtractor rel_data; 2128 DataExtractor symtab_data; 2129 DataExtractor debug_data; 2130 2131 if (ReadSectionData(rel, rel_data) && 2132 ReadSectionData(symtab, symtab_data) && 2133 ReadSectionData(debug, debug_data)) 2134 { 2135 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2136 rel_data, symtab_data, debug_data, debug); 2137 } 2138 2139 return 0; 2140 } 2141 2142 Symtab * 2143 ObjectFileELF::GetSymtab() 2144 { 2145 ModuleSP module_sp(GetModule()); 2146 if (!module_sp) 2147 return NULL; 2148 2149 // We always want to use the main object file so we (hopefully) only have one cached copy 2150 // of our symtab, dynamic sections, etc. 2151 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2152 if (module_obj_file && module_obj_file != this) 2153 return module_obj_file->GetSymtab(); 2154 2155 if (m_symtab_ap.get() == NULL) 2156 { 2157 SectionList *section_list = GetSectionList(); 2158 if (!section_list) 2159 return NULL; 2160 2161 uint64_t symbol_id = 0; 2162 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2163 2164 m_symtab_ap.reset(new Symtab(this)); 2165 2166 // Sharable objects and dynamic executables usually have 2 distinct symbol 2167 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2168 // version of the symtab that only contains global symbols. The information found 2169 // in the dynsym is therefore also found in the symtab, while the reverse is not 2170 // necessarily true. 2171 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2172 if (!symtab) 2173 { 2174 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2175 // then use the dynsym section which should always be there. 2176 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2177 } 2178 if (symtab) 2179 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2180 2181 // DT_JMPREL 2182 // If present, this entry's d_ptr member holds the address of relocation 2183 // entries associated solely with the procedure linkage table. Separating 2184 // these relocation entries lets the dynamic linker ignore them during 2185 // process initialization, if lazy binding is enabled. If this entry is 2186 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2187 // also be present. 2188 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2189 if (symbol) 2190 { 2191 // Synthesize trampoline symbols to help navigate the PLT. 2192 addr_t addr = symbol->d_ptr; 2193 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2194 if (reloc_section) 2195 { 2196 user_id_t reloc_id = reloc_section->GetID(); 2197 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2198 assert(reloc_header); 2199 2200 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2201 } 2202 } 2203 } 2204 2205 for (SectionHeaderCollIter I = m_section_headers.begin(); 2206 I != m_section_headers.end(); ++I) 2207 { 2208 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2209 { 2210 if (CalculateType() == eTypeObjectFile) 2211 { 2212 const char *section_name = I->section_name.AsCString(""); 2213 if (strstr(section_name, ".rela.debug") || 2214 strstr(section_name, ".rel.debug")) 2215 { 2216 const ELFSectionHeader &reloc_header = *I; 2217 user_id_t reloc_id = SectionIndex(I); 2218 RelocateDebugSections(&reloc_header, reloc_id); 2219 } 2220 } 2221 } 2222 } 2223 return m_symtab_ap.get(); 2224 } 2225 2226 Symbol * 2227 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2228 { 2229 if (!m_symtab_ap.get()) 2230 return nullptr; // GetSymtab() should be called first. 2231 2232 const SectionList *section_list = GetSectionList(); 2233 if (!section_list) 2234 return nullptr; 2235 2236 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2237 { 2238 AddressRange range; 2239 if (eh_frame->GetAddressRange (so_addr, range)) 2240 { 2241 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2242 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2243 if (symbol) 2244 return symbol; 2245 2246 // Note that a (stripped) symbol won't be found by GetSymtab()... 2247 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2248 if (eh_sym_section_sp.get()) 2249 { 2250 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2251 addr_t offset = file_addr - section_base; 2252 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2253 2254 Symbol eh_symbol( 2255 symbol_id, // Symbol table index. 2256 "???", // Symbol name. 2257 false, // Is the symbol name mangled? 2258 eSymbolTypeCode, // Type of this symbol. 2259 true, // Is this globally visible? 2260 false, // Is this symbol debug info? 2261 false, // Is this symbol a trampoline? 2262 true, // Is this symbol artificial? 2263 eh_sym_section_sp, // Section in which this symbol is defined or null. 2264 offset, // Offset in section or symbol value. 2265 range.GetByteSize(), // Size in bytes of this symbol. 2266 true, // Size is valid. 2267 0); // Symbol flags. 2268 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2269 return m_symtab_ap->SymbolAtIndex(symbol_id); 2270 } 2271 } 2272 } 2273 return nullptr; 2274 } 2275 2276 2277 bool 2278 ObjectFileELF::IsStripped () 2279 { 2280 // TODO: determine this for ELF 2281 return false; 2282 } 2283 2284 //===----------------------------------------------------------------------===// 2285 // Dump 2286 // 2287 // Dump the specifics of the runtime file container (such as any headers 2288 // segments, sections, etc). 2289 //---------------------------------------------------------------------- 2290 void 2291 ObjectFileELF::Dump(Stream *s) 2292 { 2293 DumpELFHeader(s, m_header); 2294 s->EOL(); 2295 DumpELFProgramHeaders(s); 2296 s->EOL(); 2297 DumpELFSectionHeaders(s); 2298 s->EOL(); 2299 SectionList *section_list = GetSectionList(); 2300 if (section_list) 2301 section_list->Dump(s, NULL, true, UINT32_MAX); 2302 Symtab *symtab = GetSymtab(); 2303 if (symtab) 2304 symtab->Dump(s, NULL, eSortOrderNone); 2305 s->EOL(); 2306 DumpDependentModules(s); 2307 s->EOL(); 2308 } 2309 2310 //---------------------------------------------------------------------- 2311 // DumpELFHeader 2312 // 2313 // Dump the ELF header to the specified output stream 2314 //---------------------------------------------------------------------- 2315 void 2316 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2317 { 2318 s->PutCString("ELF Header\n"); 2319 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2320 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2321 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2322 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2323 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2324 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2325 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2326 2327 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2328 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2329 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2330 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2331 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2332 2333 s->Printf("e_type = 0x%4.4x ", header.e_type); 2334 DumpELFHeader_e_type(s, header.e_type); 2335 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2336 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2337 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2338 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2339 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2340 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2341 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2342 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2343 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2344 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2345 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2346 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2347 } 2348 2349 //---------------------------------------------------------------------- 2350 // DumpELFHeader_e_type 2351 // 2352 // Dump an token value for the ELF header member e_type 2353 //---------------------------------------------------------------------- 2354 void 2355 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2356 { 2357 switch (e_type) 2358 { 2359 case ET_NONE: *s << "ET_NONE"; break; 2360 case ET_REL: *s << "ET_REL"; break; 2361 case ET_EXEC: *s << "ET_EXEC"; break; 2362 case ET_DYN: *s << "ET_DYN"; break; 2363 case ET_CORE: *s << "ET_CORE"; break; 2364 default: 2365 break; 2366 } 2367 } 2368 2369 //---------------------------------------------------------------------- 2370 // DumpELFHeader_e_ident_EI_DATA 2371 // 2372 // Dump an token value for the ELF header member e_ident[EI_DATA] 2373 //---------------------------------------------------------------------- 2374 void 2375 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2376 { 2377 switch (ei_data) 2378 { 2379 case ELFDATANONE: *s << "ELFDATANONE"; break; 2380 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2381 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2382 default: 2383 break; 2384 } 2385 } 2386 2387 2388 //---------------------------------------------------------------------- 2389 // DumpELFProgramHeader 2390 // 2391 // Dump a single ELF program header to the specified output stream 2392 //---------------------------------------------------------------------- 2393 void 2394 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 2395 { 2396 DumpELFProgramHeader_p_type(s, ph.p_type); 2397 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 2398 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 2399 2400 DumpELFProgramHeader_p_flags(s, ph.p_flags); 2401 s->Printf(") %8.8" PRIx64, ph.p_align); 2402 } 2403 2404 //---------------------------------------------------------------------- 2405 // DumpELFProgramHeader_p_type 2406 // 2407 // Dump an token value for the ELF program header member p_type which 2408 // describes the type of the program header 2409 // ---------------------------------------------------------------------- 2410 void 2411 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 2412 { 2413 const int kStrWidth = 15; 2414 switch (p_type) 2415 { 2416 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 2417 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 2418 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 2419 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 2420 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 2421 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 2422 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 2423 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 2424 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 2425 default: 2426 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 2427 break; 2428 } 2429 } 2430 2431 2432 //---------------------------------------------------------------------- 2433 // DumpELFProgramHeader_p_flags 2434 // 2435 // Dump an token value for the ELF program header member p_flags 2436 //---------------------------------------------------------------------- 2437 void 2438 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 2439 { 2440 *s << ((p_flags & PF_X) ? "PF_X" : " ") 2441 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 2442 << ((p_flags & PF_W) ? "PF_W" : " ") 2443 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 2444 << ((p_flags & PF_R) ? "PF_R" : " "); 2445 } 2446 2447 //---------------------------------------------------------------------- 2448 // DumpELFProgramHeaders 2449 // 2450 // Dump all of the ELF program header to the specified output stream 2451 //---------------------------------------------------------------------- 2452 void 2453 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 2454 { 2455 if (ParseProgramHeaders()) 2456 { 2457 s->PutCString("Program Headers\n"); 2458 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 2459 "p_filesz p_memsz p_flags p_align\n"); 2460 s->PutCString("==== --------------- -------- -------- -------- " 2461 "-------- -------- ------------------------- --------\n"); 2462 2463 uint32_t idx = 0; 2464 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 2465 I != m_program_headers.end(); ++I, ++idx) 2466 { 2467 s->Printf("[%2u] ", idx); 2468 ObjectFileELF::DumpELFProgramHeader(s, *I); 2469 s->EOL(); 2470 } 2471 } 2472 } 2473 2474 //---------------------------------------------------------------------- 2475 // DumpELFSectionHeader 2476 // 2477 // Dump a single ELF section header to the specified output stream 2478 //---------------------------------------------------------------------- 2479 void 2480 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 2481 { 2482 s->Printf("%8.8x ", sh.sh_name); 2483 DumpELFSectionHeader_sh_type(s, sh.sh_type); 2484 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 2485 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 2486 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 2487 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 2488 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 2489 } 2490 2491 //---------------------------------------------------------------------- 2492 // DumpELFSectionHeader_sh_type 2493 // 2494 // Dump an token value for the ELF section header member sh_type which 2495 // describes the type of the section 2496 //---------------------------------------------------------------------- 2497 void 2498 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 2499 { 2500 const int kStrWidth = 12; 2501 switch (sh_type) 2502 { 2503 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 2504 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 2505 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 2506 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 2507 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 2508 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 2509 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 2510 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 2511 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 2512 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 2513 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 2514 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 2515 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 2516 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 2517 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 2518 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 2519 default: 2520 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 2521 break; 2522 } 2523 } 2524 2525 //---------------------------------------------------------------------- 2526 // DumpELFSectionHeader_sh_flags 2527 // 2528 // Dump an token value for the ELF section header member sh_flags 2529 //---------------------------------------------------------------------- 2530 void 2531 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 2532 { 2533 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 2534 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 2535 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 2536 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 2537 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 2538 } 2539 2540 //---------------------------------------------------------------------- 2541 // DumpELFSectionHeaders 2542 // 2543 // Dump all of the ELF section header to the specified output stream 2544 //---------------------------------------------------------------------- 2545 void 2546 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 2547 { 2548 if (!ParseSectionHeaders()) 2549 return; 2550 2551 s->PutCString("Section Headers\n"); 2552 s->PutCString("IDX name type flags " 2553 "addr offset size link info addralgn " 2554 "entsize Name\n"); 2555 s->PutCString("==== -------- ------------ -------------------------------- " 2556 "-------- -------- -------- -------- -------- -------- " 2557 "-------- ====================\n"); 2558 2559 uint32_t idx = 0; 2560 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 2561 I != m_section_headers.end(); ++I, ++idx) 2562 { 2563 s->Printf("[%2u] ", idx); 2564 ObjectFileELF::DumpELFSectionHeader(s, *I); 2565 const char* section_name = I->section_name.AsCString(""); 2566 if (section_name) 2567 *s << ' ' << section_name << "\n"; 2568 } 2569 } 2570 2571 void 2572 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 2573 { 2574 size_t num_modules = ParseDependentModules(); 2575 2576 if (num_modules > 0) 2577 { 2578 s->PutCString("Dependent Modules:\n"); 2579 for (unsigned i = 0; i < num_modules; ++i) 2580 { 2581 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 2582 s->Printf(" %s\n", spec.GetFilename().GetCString()); 2583 } 2584 } 2585 } 2586 2587 bool 2588 ObjectFileELF::GetArchitecture (ArchSpec &arch) 2589 { 2590 if (!ParseHeader()) 2591 return false; 2592 2593 if (m_section_headers.empty()) 2594 { 2595 // Allow elf notes to be parsed which may affect the detected architecture. 2596 ParseSectionHeaders(); 2597 } 2598 2599 arch = m_arch_spec; 2600 return true; 2601 } 2602 2603 ObjectFile::Type 2604 ObjectFileELF::CalculateType() 2605 { 2606 switch (m_header.e_type) 2607 { 2608 case llvm::ELF::ET_NONE: 2609 // 0 - No file type 2610 return eTypeUnknown; 2611 2612 case llvm::ELF::ET_REL: 2613 // 1 - Relocatable file 2614 return eTypeObjectFile; 2615 2616 case llvm::ELF::ET_EXEC: 2617 // 2 - Executable file 2618 return eTypeExecutable; 2619 2620 case llvm::ELF::ET_DYN: 2621 // 3 - Shared object file 2622 return eTypeSharedLibrary; 2623 2624 case ET_CORE: 2625 // 4 - Core file 2626 return eTypeCoreFile; 2627 2628 default: 2629 break; 2630 } 2631 return eTypeUnknown; 2632 } 2633 2634 ObjectFile::Strata 2635 ObjectFileELF::CalculateStrata() 2636 { 2637 switch (m_header.e_type) 2638 { 2639 case llvm::ELF::ET_NONE: 2640 // 0 - No file type 2641 return eStrataUnknown; 2642 2643 case llvm::ELF::ET_REL: 2644 // 1 - Relocatable file 2645 return eStrataUnknown; 2646 2647 case llvm::ELF::ET_EXEC: 2648 // 2 - Executable file 2649 // TODO: is there any way to detect that an executable is a kernel 2650 // related executable by inspecting the program headers, section 2651 // headers, symbols, or any other flag bits??? 2652 return eStrataUser; 2653 2654 case llvm::ELF::ET_DYN: 2655 // 3 - Shared object file 2656 // TODO: is there any way to detect that an shared library is a kernel 2657 // related executable by inspecting the program headers, section 2658 // headers, symbols, or any other flag bits??? 2659 return eStrataUnknown; 2660 2661 case ET_CORE: 2662 // 4 - Core file 2663 // TODO: is there any way to detect that an core file is a kernel 2664 // related executable by inspecting the program headers, section 2665 // headers, symbols, or any other flag bits??? 2666 return eStrataUnknown; 2667 2668 default: 2669 break; 2670 } 2671 return eStrataUnknown; 2672 } 2673 2674