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