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