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 ArchSpec arch; 1750 1751 if (GetArchitecture(arch) && 1752 arch.GetMachine() == llvm::Triple::arm) 1753 { 1754 // ELF symbol tables may contain some mapping symbols. They provide 1755 // information about the underlying data. There are three of them 1756 // currently defined: 1757 // $a[.<any>]* - marks an ARM instruction sequence 1758 // $t[.<any>]* - marks a THUMB instruction sequence 1759 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 1760 // These symbols interfere with normal debugger operations and we 1761 // don't need them. We can drop them here. 1762 1763 static const llvm::StringRef g_armelf_arm_marker("$a"); 1764 static const llvm::StringRef g_armelf_thumb_marker("$t"); 1765 static const llvm::StringRef g_armelf_data_marker("$d"); 1766 llvm::StringRef symbol_name_ref(symbol_name); 1767 1768 if (symbol_name && 1769 (symbol_name_ref.startswith(g_armelf_arm_marker) || 1770 symbol_name_ref.startswith(g_armelf_thumb_marker) || 1771 symbol_name_ref.startswith(g_armelf_data_marker))) 1772 continue; 1773 } 1774 1775 // If the symbol section we've found has no data (SHT_NOBITS), then check the module section 1776 // list. This can happen if we're parsing the debug file and it has no .text section, for example. 1777 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1778 { 1779 ModuleSP module_sp(GetModule()); 1780 if (module_sp) 1781 { 1782 SectionList *module_section_list = module_sp->GetSectionList(); 1783 if (module_section_list && module_section_list != section_list) 1784 { 1785 const ConstString §_name = symbol_section_sp->GetName(); 1786 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1787 if (section_sp && section_sp->GetFileSize()) 1788 { 1789 symbol_section_sp = section_sp; 1790 } 1791 } 1792 } 1793 } 1794 1795 uint64_t symbol_value = symbol.st_value; 1796 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 1797 symbol_value -= symbol_section_sp->GetFileAddress(); 1798 bool is_global = symbol.getBinding() == STB_GLOBAL; 1799 uint32_t flags = symbol.st_other << 8 | symbol.st_info; 1800 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1801 Symbol dc_symbol( 1802 i + start_id, // ID is the original symbol table index. 1803 symbol_name, // Symbol name. 1804 is_mangled, // Is the symbol name mangled? 1805 symbol_type, // Type of this symbol 1806 is_global, // Is this globally visible? 1807 false, // Is this symbol debug info? 1808 false, // Is this symbol a trampoline? 1809 false, // Is this symbol artificial? 1810 symbol_section_sp, // Section in which this symbol is defined or null. 1811 symbol_value, // Offset in section or symbol value. 1812 symbol.st_size, // Size in bytes of this symbol. 1813 true, // Size is valid 1814 flags); // Symbol flags. 1815 symtab->AddSymbol(dc_symbol); 1816 } 1817 1818 return i; 1819 } 1820 1821 unsigned 1822 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 1823 { 1824 if (symtab->GetObjectFile() != this) 1825 { 1826 // If the symbol table section is owned by a different object file, have it do the 1827 // parsing. 1828 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 1829 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 1830 } 1831 1832 // Get section list for this object file. 1833 SectionList *section_list = m_sections_ap.get(); 1834 if (!section_list) 1835 return 0; 1836 1837 user_id_t symtab_id = symtab->GetID(); 1838 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 1839 assert(symtab_hdr->sh_type == SHT_SYMTAB || 1840 symtab_hdr->sh_type == SHT_DYNSYM); 1841 1842 // sh_link: section header index of associated string table. 1843 // Section ID's are ones based. 1844 user_id_t strtab_id = symtab_hdr->sh_link + 1; 1845 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 1846 1847 if (symtab && strtab) 1848 { 1849 assert (symtab->GetObjectFile() == this); 1850 assert (strtab->GetObjectFile() == this); 1851 1852 DataExtractor symtab_data; 1853 DataExtractor strtab_data; 1854 if (ReadSectionData(symtab, symtab_data) && 1855 ReadSectionData(strtab, strtab_data)) 1856 { 1857 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 1858 1859 return ParseSymbols(symbol_table, start_id, section_list, 1860 num_symbols, symtab_data, strtab_data); 1861 } 1862 } 1863 1864 return 0; 1865 } 1866 1867 size_t 1868 ObjectFileELF::ParseDynamicSymbols() 1869 { 1870 if (m_dynamic_symbols.size()) 1871 return m_dynamic_symbols.size(); 1872 1873 SectionList *section_list = GetSectionList(); 1874 if (!section_list) 1875 return 0; 1876 1877 // Find the SHT_DYNAMIC section. 1878 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1879 if (!dynsym) 1880 return 0; 1881 assert (dynsym->GetObjectFile() == this); 1882 1883 ELFDynamic symbol; 1884 DataExtractor dynsym_data; 1885 if (ReadSectionData(dynsym, dynsym_data)) 1886 { 1887 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1888 lldb::offset_t cursor = 0; 1889 1890 while (cursor < section_size) 1891 { 1892 if (!symbol.Parse(dynsym_data, &cursor)) 1893 break; 1894 1895 m_dynamic_symbols.push_back(symbol); 1896 } 1897 } 1898 1899 return m_dynamic_symbols.size(); 1900 } 1901 1902 const ELFDynamic * 1903 ObjectFileELF::FindDynamicSymbol(unsigned tag) 1904 { 1905 if (!ParseDynamicSymbols()) 1906 return NULL; 1907 1908 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 1909 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 1910 for ( ; I != E; ++I) 1911 { 1912 ELFDynamic *symbol = &*I; 1913 1914 if (symbol->d_tag == tag) 1915 return symbol; 1916 } 1917 1918 return NULL; 1919 } 1920 1921 unsigned 1922 ObjectFileELF::PLTRelocationType() 1923 { 1924 // DT_PLTREL 1925 // This member specifies the type of relocation entry to which the 1926 // procedure linkage table refers. The d_val member holds DT_REL or 1927 // DT_RELA, as appropriate. All relocations in a procedure linkage table 1928 // must use the same relocation. 1929 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 1930 1931 if (symbol) 1932 return symbol->d_val; 1933 1934 return 0; 1935 } 1936 1937 static unsigned 1938 ParsePLTRelocations(Symtab *symbol_table, 1939 user_id_t start_id, 1940 unsigned rel_type, 1941 const ELFHeader *hdr, 1942 const ELFSectionHeader *rel_hdr, 1943 const ELFSectionHeader *plt_hdr, 1944 const ELFSectionHeader *sym_hdr, 1945 const lldb::SectionSP &plt_section_sp, 1946 DataExtractor &rel_data, 1947 DataExtractor &symtab_data, 1948 DataExtractor &strtab_data) 1949 { 1950 ELFRelocation rel(rel_type); 1951 ELFSymbol symbol; 1952 lldb::offset_t offset = 0; 1953 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 1954 // So round the entsize up by the alignment if addralign is set. 1955 const elf_xword plt_entsize = plt_hdr->sh_addralign ? 1956 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 1957 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 1958 1959 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 1960 reloc_info_fn reloc_type; 1961 reloc_info_fn reloc_symbol; 1962 1963 if (hdr->Is32Bit()) 1964 { 1965 reloc_type = ELFRelocation::RelocType32; 1966 reloc_symbol = ELFRelocation::RelocSymbol32; 1967 } 1968 else 1969 { 1970 reloc_type = ELFRelocation::RelocType64; 1971 reloc_symbol = ELFRelocation::RelocSymbol64; 1972 } 1973 1974 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 1975 unsigned i; 1976 for (i = 0; i < num_relocations; ++i) 1977 { 1978 if (rel.Parse(rel_data, &offset) == false) 1979 break; 1980 1981 if (reloc_type(rel) != slot_type) 1982 continue; 1983 1984 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 1985 uint64_t plt_index = (i + 1) * plt_entsize; 1986 1987 if (!symbol.Parse(symtab_data, &symbol_offset)) 1988 break; 1989 1990 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1991 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1992 1993 Symbol jump_symbol( 1994 i + start_id, // Symbol table index 1995 symbol_name, // symbol name. 1996 is_mangled, // is the symbol name mangled? 1997 eSymbolTypeTrampoline, // Type of this symbol 1998 false, // Is this globally visible? 1999 false, // Is this symbol debug info? 2000 true, // Is this symbol a trampoline? 2001 true, // Is this symbol artificial? 2002 plt_section_sp, // Section in which this symbol is defined or null. 2003 plt_index, // Offset in section or symbol value. 2004 plt_entsize, // Size in bytes of this symbol. 2005 true, // Size is valid 2006 0); // Symbol flags. 2007 2008 symbol_table->AddSymbol(jump_symbol); 2009 } 2010 2011 return i; 2012 } 2013 2014 unsigned 2015 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2016 user_id_t start_id, 2017 const ELFSectionHeaderInfo *rel_hdr, 2018 user_id_t rel_id) 2019 { 2020 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2021 2022 // The link field points to the associated symbol table. The info field 2023 // points to the section holding the plt. 2024 user_id_t symtab_id = rel_hdr->sh_link; 2025 user_id_t plt_id = rel_hdr->sh_info; 2026 2027 if (!symtab_id || !plt_id) 2028 return 0; 2029 2030 // Section ID's are ones based; 2031 symtab_id++; 2032 plt_id++; 2033 2034 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2035 if (!plt_hdr) 2036 return 0; 2037 2038 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2039 if (!sym_hdr) 2040 return 0; 2041 2042 SectionList *section_list = m_sections_ap.get(); 2043 if (!section_list) 2044 return 0; 2045 2046 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2047 if (!rel_section) 2048 return 0; 2049 2050 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2051 if (!plt_section_sp) 2052 return 0; 2053 2054 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2055 if (!symtab) 2056 return 0; 2057 2058 // sh_link points to associated string table. 2059 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2060 if (!strtab) 2061 return 0; 2062 2063 DataExtractor rel_data; 2064 if (!ReadSectionData(rel_section, rel_data)) 2065 return 0; 2066 2067 DataExtractor symtab_data; 2068 if (!ReadSectionData(symtab, symtab_data)) 2069 return 0; 2070 2071 DataExtractor strtab_data; 2072 if (!ReadSectionData(strtab, strtab_data)) 2073 return 0; 2074 2075 unsigned rel_type = PLTRelocationType(); 2076 if (!rel_type) 2077 return 0; 2078 2079 return ParsePLTRelocations (symbol_table, 2080 start_id, 2081 rel_type, 2082 &m_header, 2083 rel_hdr, 2084 plt_hdr, 2085 sym_hdr, 2086 plt_section_sp, 2087 rel_data, 2088 symtab_data, 2089 strtab_data); 2090 } 2091 2092 unsigned 2093 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2094 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2095 DataExtractor &rel_data, DataExtractor &symtab_data, 2096 DataExtractor &debug_data, Section* rel_section) 2097 { 2098 ELFRelocation rel(rel_hdr->sh_type); 2099 lldb::addr_t offset = 0; 2100 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2101 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2102 reloc_info_fn reloc_type; 2103 reloc_info_fn reloc_symbol; 2104 2105 if (hdr->Is32Bit()) 2106 { 2107 reloc_type = ELFRelocation::RelocType32; 2108 reloc_symbol = ELFRelocation::RelocSymbol32; 2109 } 2110 else 2111 { 2112 reloc_type = ELFRelocation::RelocType64; 2113 reloc_symbol = ELFRelocation::RelocSymbol64; 2114 } 2115 2116 for (unsigned i = 0; i < num_relocations; ++i) 2117 { 2118 if (rel.Parse(rel_data, &offset) == false) 2119 break; 2120 2121 Symbol* symbol = NULL; 2122 2123 if (hdr->Is32Bit()) 2124 { 2125 switch (reloc_type(rel)) { 2126 case R_386_32: 2127 case R_386_PC32: 2128 default: 2129 assert(false && "unexpected relocation type"); 2130 } 2131 } else { 2132 switch (reloc_type(rel)) { 2133 case R_X86_64_64: 2134 { 2135 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2136 if (symbol) 2137 { 2138 addr_t value = symbol->GetAddress().GetFileAddress(); 2139 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2140 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2141 *dst = value + ELFRelocation::RelocAddend64(rel); 2142 } 2143 break; 2144 } 2145 case R_X86_64_32: 2146 case R_X86_64_32S: 2147 { 2148 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2149 if (symbol) 2150 { 2151 addr_t value = symbol->GetAddress().GetFileAddress(); 2152 value += ELFRelocation::RelocAddend32(rel); 2153 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2154 (reloc_type(rel) == R_X86_64_32S && 2155 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2156 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2157 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2158 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2159 *dst = truncated_addr; 2160 } 2161 break; 2162 } 2163 case R_X86_64_PC32: 2164 default: 2165 assert(false && "unexpected relocation type"); 2166 } 2167 } 2168 } 2169 2170 return 0; 2171 } 2172 2173 unsigned 2174 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2175 { 2176 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2177 2178 // Parse in the section list if needed. 2179 SectionList *section_list = GetSectionList(); 2180 if (!section_list) 2181 return 0; 2182 2183 // Section ID's are ones based. 2184 user_id_t symtab_id = rel_hdr->sh_link + 1; 2185 user_id_t debug_id = rel_hdr->sh_info + 1; 2186 2187 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2188 if (!symtab_hdr) 2189 return 0; 2190 2191 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2192 if (!debug_hdr) 2193 return 0; 2194 2195 Section *rel = section_list->FindSectionByID(rel_id).get(); 2196 if (!rel) 2197 return 0; 2198 2199 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2200 if (!symtab) 2201 return 0; 2202 2203 Section *debug = section_list->FindSectionByID(debug_id).get(); 2204 if (!debug) 2205 return 0; 2206 2207 DataExtractor rel_data; 2208 DataExtractor symtab_data; 2209 DataExtractor debug_data; 2210 2211 if (ReadSectionData(rel, rel_data) && 2212 ReadSectionData(symtab, symtab_data) && 2213 ReadSectionData(debug, debug_data)) 2214 { 2215 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2216 rel_data, symtab_data, debug_data, debug); 2217 } 2218 2219 return 0; 2220 } 2221 2222 Symtab * 2223 ObjectFileELF::GetSymtab() 2224 { 2225 ModuleSP module_sp(GetModule()); 2226 if (!module_sp) 2227 return NULL; 2228 2229 // We always want to use the main object file so we (hopefully) only have one cached copy 2230 // of our symtab, dynamic sections, etc. 2231 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2232 if (module_obj_file && module_obj_file != this) 2233 return module_obj_file->GetSymtab(); 2234 2235 if (m_symtab_ap.get() == NULL) 2236 { 2237 SectionList *section_list = GetSectionList(); 2238 if (!section_list) 2239 return NULL; 2240 2241 uint64_t symbol_id = 0; 2242 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2243 2244 m_symtab_ap.reset(new Symtab(this)); 2245 2246 // Sharable objects and dynamic executables usually have 2 distinct symbol 2247 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2248 // version of the symtab that only contains global symbols. The information found 2249 // in the dynsym is therefore also found in the symtab, while the reverse is not 2250 // necessarily true. 2251 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2252 if (!symtab) 2253 { 2254 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2255 // then use the dynsym section which should always be there. 2256 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2257 } 2258 if (symtab) 2259 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2260 2261 // DT_JMPREL 2262 // If present, this entry's d_ptr member holds the address of relocation 2263 // entries associated solely with the procedure linkage table. Separating 2264 // these relocation entries lets the dynamic linker ignore them during 2265 // process initialization, if lazy binding is enabled. If this entry is 2266 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2267 // also be present. 2268 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2269 if (symbol) 2270 { 2271 // Synthesize trampoline symbols to help navigate the PLT. 2272 addr_t addr = symbol->d_ptr; 2273 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2274 if (reloc_section) 2275 { 2276 user_id_t reloc_id = reloc_section->GetID(); 2277 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2278 assert(reloc_header); 2279 2280 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2281 } 2282 } 2283 } 2284 2285 for (SectionHeaderCollIter I = m_section_headers.begin(); 2286 I != m_section_headers.end(); ++I) 2287 { 2288 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2289 { 2290 if (CalculateType() == eTypeObjectFile) 2291 { 2292 const char *section_name = I->section_name.AsCString(""); 2293 if (strstr(section_name, ".rela.debug") || 2294 strstr(section_name, ".rel.debug")) 2295 { 2296 const ELFSectionHeader &reloc_header = *I; 2297 user_id_t reloc_id = SectionIndex(I); 2298 RelocateDebugSections(&reloc_header, reloc_id); 2299 } 2300 } 2301 } 2302 } 2303 return m_symtab_ap.get(); 2304 } 2305 2306 Symbol * 2307 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2308 { 2309 if (!m_symtab_ap.get()) 2310 return nullptr; // GetSymtab() should be called first. 2311 2312 const SectionList *section_list = GetSectionList(); 2313 if (!section_list) 2314 return nullptr; 2315 2316 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2317 { 2318 AddressRange range; 2319 if (eh_frame->GetAddressRange (so_addr, range)) 2320 { 2321 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2322 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2323 if (symbol) 2324 return symbol; 2325 2326 // Note that a (stripped) symbol won't be found by GetSymtab()... 2327 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2328 if (eh_sym_section_sp.get()) 2329 { 2330 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2331 addr_t offset = file_addr - section_base; 2332 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2333 2334 Symbol eh_symbol( 2335 symbol_id, // Symbol table index. 2336 "???", // Symbol name. 2337 false, // Is the symbol name mangled? 2338 eSymbolTypeCode, // Type of this symbol. 2339 true, // Is this globally visible? 2340 false, // Is this symbol debug info? 2341 false, // Is this symbol a trampoline? 2342 true, // Is this symbol artificial? 2343 eh_sym_section_sp, // Section in which this symbol is defined or null. 2344 offset, // Offset in section or symbol value. 2345 range.GetByteSize(), // Size in bytes of this symbol. 2346 true, // Size is valid. 2347 0); // Symbol flags. 2348 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2349 return m_symtab_ap->SymbolAtIndex(symbol_id); 2350 } 2351 } 2352 } 2353 return nullptr; 2354 } 2355 2356 2357 bool 2358 ObjectFileELF::IsStripped () 2359 { 2360 // TODO: determine this for ELF 2361 return false; 2362 } 2363 2364 //===----------------------------------------------------------------------===// 2365 // Dump 2366 // 2367 // Dump the specifics of the runtime file container (such as any headers 2368 // segments, sections, etc). 2369 //---------------------------------------------------------------------- 2370 void 2371 ObjectFileELF::Dump(Stream *s) 2372 { 2373 DumpELFHeader(s, m_header); 2374 s->EOL(); 2375 DumpELFProgramHeaders(s); 2376 s->EOL(); 2377 DumpELFSectionHeaders(s); 2378 s->EOL(); 2379 SectionList *section_list = GetSectionList(); 2380 if (section_list) 2381 section_list->Dump(s, NULL, true, UINT32_MAX); 2382 Symtab *symtab = GetSymtab(); 2383 if (symtab) 2384 symtab->Dump(s, NULL, eSortOrderNone); 2385 s->EOL(); 2386 DumpDependentModules(s); 2387 s->EOL(); 2388 } 2389 2390 //---------------------------------------------------------------------- 2391 // DumpELFHeader 2392 // 2393 // Dump the ELF header to the specified output stream 2394 //---------------------------------------------------------------------- 2395 void 2396 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2397 { 2398 s->PutCString("ELF Header\n"); 2399 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2400 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2401 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2402 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2403 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2404 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2405 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2406 2407 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2408 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2409 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2410 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2411 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2412 2413 s->Printf("e_type = 0x%4.4x ", header.e_type); 2414 DumpELFHeader_e_type(s, header.e_type); 2415 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2416 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2417 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2418 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2419 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2420 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2421 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2422 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2423 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2424 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2425 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2426 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2427 } 2428 2429 //---------------------------------------------------------------------- 2430 // DumpELFHeader_e_type 2431 // 2432 // Dump an token value for the ELF header member e_type 2433 //---------------------------------------------------------------------- 2434 void 2435 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2436 { 2437 switch (e_type) 2438 { 2439 case ET_NONE: *s << "ET_NONE"; break; 2440 case ET_REL: *s << "ET_REL"; break; 2441 case ET_EXEC: *s << "ET_EXEC"; break; 2442 case ET_DYN: *s << "ET_DYN"; break; 2443 case ET_CORE: *s << "ET_CORE"; break; 2444 default: 2445 break; 2446 } 2447 } 2448 2449 //---------------------------------------------------------------------- 2450 // DumpELFHeader_e_ident_EI_DATA 2451 // 2452 // Dump an token value for the ELF header member e_ident[EI_DATA] 2453 //---------------------------------------------------------------------- 2454 void 2455 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2456 { 2457 switch (ei_data) 2458 { 2459 case ELFDATANONE: *s << "ELFDATANONE"; break; 2460 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2461 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2462 default: 2463 break; 2464 } 2465 } 2466 2467 2468 //---------------------------------------------------------------------- 2469 // DumpELFProgramHeader 2470 // 2471 // Dump a single ELF program header to the specified output stream 2472 //---------------------------------------------------------------------- 2473 void 2474 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 2475 { 2476 DumpELFProgramHeader_p_type(s, ph.p_type); 2477 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 2478 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 2479 2480 DumpELFProgramHeader_p_flags(s, ph.p_flags); 2481 s->Printf(") %8.8" PRIx64, ph.p_align); 2482 } 2483 2484 //---------------------------------------------------------------------- 2485 // DumpELFProgramHeader_p_type 2486 // 2487 // Dump an token value for the ELF program header member p_type which 2488 // describes the type of the program header 2489 // ---------------------------------------------------------------------- 2490 void 2491 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 2492 { 2493 const int kStrWidth = 15; 2494 switch (p_type) 2495 { 2496 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 2497 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 2498 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 2499 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 2500 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 2501 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 2502 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 2503 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 2504 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 2505 default: 2506 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 2507 break; 2508 } 2509 } 2510 2511 2512 //---------------------------------------------------------------------- 2513 // DumpELFProgramHeader_p_flags 2514 // 2515 // Dump an token value for the ELF program header member p_flags 2516 //---------------------------------------------------------------------- 2517 void 2518 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 2519 { 2520 *s << ((p_flags & PF_X) ? "PF_X" : " ") 2521 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 2522 << ((p_flags & PF_W) ? "PF_W" : " ") 2523 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 2524 << ((p_flags & PF_R) ? "PF_R" : " "); 2525 } 2526 2527 //---------------------------------------------------------------------- 2528 // DumpELFProgramHeaders 2529 // 2530 // Dump all of the ELF program header to the specified output stream 2531 //---------------------------------------------------------------------- 2532 void 2533 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 2534 { 2535 if (ParseProgramHeaders()) 2536 { 2537 s->PutCString("Program Headers\n"); 2538 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 2539 "p_filesz p_memsz p_flags p_align\n"); 2540 s->PutCString("==== --------------- -------- -------- -------- " 2541 "-------- -------- ------------------------- --------\n"); 2542 2543 uint32_t idx = 0; 2544 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 2545 I != m_program_headers.end(); ++I, ++idx) 2546 { 2547 s->Printf("[%2u] ", idx); 2548 ObjectFileELF::DumpELFProgramHeader(s, *I); 2549 s->EOL(); 2550 } 2551 } 2552 } 2553 2554 //---------------------------------------------------------------------- 2555 // DumpELFSectionHeader 2556 // 2557 // Dump a single ELF section header to the specified output stream 2558 //---------------------------------------------------------------------- 2559 void 2560 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 2561 { 2562 s->Printf("%8.8x ", sh.sh_name); 2563 DumpELFSectionHeader_sh_type(s, sh.sh_type); 2564 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 2565 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 2566 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 2567 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 2568 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 2569 } 2570 2571 //---------------------------------------------------------------------- 2572 // DumpELFSectionHeader_sh_type 2573 // 2574 // Dump an token value for the ELF section header member sh_type which 2575 // describes the type of the section 2576 //---------------------------------------------------------------------- 2577 void 2578 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 2579 { 2580 const int kStrWidth = 12; 2581 switch (sh_type) 2582 { 2583 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 2584 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 2585 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 2586 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 2587 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 2588 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 2589 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 2590 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 2591 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 2592 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 2593 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 2594 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 2595 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 2596 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 2597 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 2598 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 2599 default: 2600 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 2601 break; 2602 } 2603 } 2604 2605 //---------------------------------------------------------------------- 2606 // DumpELFSectionHeader_sh_flags 2607 // 2608 // Dump an token value for the ELF section header member sh_flags 2609 //---------------------------------------------------------------------- 2610 void 2611 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 2612 { 2613 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 2614 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 2615 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 2616 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 2617 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 2618 } 2619 2620 //---------------------------------------------------------------------- 2621 // DumpELFSectionHeaders 2622 // 2623 // Dump all of the ELF section header to the specified output stream 2624 //---------------------------------------------------------------------- 2625 void 2626 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 2627 { 2628 if (!ParseSectionHeaders()) 2629 return; 2630 2631 s->PutCString("Section Headers\n"); 2632 s->PutCString("IDX name type flags " 2633 "addr offset size link info addralgn " 2634 "entsize Name\n"); 2635 s->PutCString("==== -------- ------------ -------------------------------- " 2636 "-------- -------- -------- -------- -------- -------- " 2637 "-------- ====================\n"); 2638 2639 uint32_t idx = 0; 2640 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 2641 I != m_section_headers.end(); ++I, ++idx) 2642 { 2643 s->Printf("[%2u] ", idx); 2644 ObjectFileELF::DumpELFSectionHeader(s, *I); 2645 const char* section_name = I->section_name.AsCString(""); 2646 if (section_name) 2647 *s << ' ' << section_name << "\n"; 2648 } 2649 } 2650 2651 void 2652 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 2653 { 2654 size_t num_modules = ParseDependentModules(); 2655 2656 if (num_modules > 0) 2657 { 2658 s->PutCString("Dependent Modules:\n"); 2659 for (unsigned i = 0; i < num_modules; ++i) 2660 { 2661 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 2662 s->Printf(" %s\n", spec.GetFilename().GetCString()); 2663 } 2664 } 2665 } 2666 2667 bool 2668 ObjectFileELF::GetArchitecture (ArchSpec &arch) 2669 { 2670 if (!ParseHeader()) 2671 return false; 2672 2673 if (m_section_headers.empty()) 2674 { 2675 // Allow elf notes to be parsed which may affect the detected architecture. 2676 ParseSectionHeaders(); 2677 } 2678 2679 arch = m_arch_spec; 2680 return true; 2681 } 2682 2683 ObjectFile::Type 2684 ObjectFileELF::CalculateType() 2685 { 2686 switch (m_header.e_type) 2687 { 2688 case llvm::ELF::ET_NONE: 2689 // 0 - No file type 2690 return eTypeUnknown; 2691 2692 case llvm::ELF::ET_REL: 2693 // 1 - Relocatable file 2694 return eTypeObjectFile; 2695 2696 case llvm::ELF::ET_EXEC: 2697 // 2 - Executable file 2698 return eTypeExecutable; 2699 2700 case llvm::ELF::ET_DYN: 2701 // 3 - Shared object file 2702 return eTypeSharedLibrary; 2703 2704 case ET_CORE: 2705 // 4 - Core file 2706 return eTypeCoreFile; 2707 2708 default: 2709 break; 2710 } 2711 return eTypeUnknown; 2712 } 2713 2714 ObjectFile::Strata 2715 ObjectFileELF::CalculateStrata() 2716 { 2717 switch (m_header.e_type) 2718 { 2719 case llvm::ELF::ET_NONE: 2720 // 0 - No file type 2721 return eStrataUnknown; 2722 2723 case llvm::ELF::ET_REL: 2724 // 1 - Relocatable file 2725 return eStrataUnknown; 2726 2727 case llvm::ELF::ET_EXEC: 2728 // 2 - Executable file 2729 // TODO: is there any way to detect that an executable is a kernel 2730 // related executable by inspecting the program headers, section 2731 // headers, symbols, or any other flag bits??? 2732 return eStrataUser; 2733 2734 case llvm::ELF::ET_DYN: 2735 // 3 - Shared object file 2736 // TODO: is there any way to detect that an shared library is a kernel 2737 // related executable by inspecting the program headers, section 2738 // headers, symbols, or any other flag bits??? 2739 return eStrataUnknown; 2740 2741 case ET_CORE: 2742 // 4 - Core file 2743 // TODO: is there any way to detect that an core file is a kernel 2744 // related executable by inspecting the program headers, section 2745 // headers, symbols, or any other flag bits??? 2746 return eStrataUnknown; 2747 2748 default: 2749 break; 2750 } 2751 return eStrataUnknown; 2752 } 2753 2754