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