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