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