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