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 #include <unordered_map> 15 16 #include "lldb/Core/ArchSpec.h" 17 #include "lldb/Core/DataBuffer.h" 18 #include "lldb/Core/Error.h" 19 #include "lldb/Core/FileSpecList.h" 20 #include "lldb/Core/Log.h" 21 #include "lldb/Core/Module.h" 22 #include "lldb/Core/ModuleSpec.h" 23 #include "lldb/Core/PluginManager.h" 24 #include "lldb/Core/Section.h" 25 #include "lldb/Core/Stream.h" 26 #include "lldb/Core/Timer.h" 27 #include "lldb/Symbol/DWARFCallFrameInfo.h" 28 #include "lldb/Symbol/SymbolContext.h" 29 #include "lldb/Target/SectionLoadList.h" 30 #include "lldb/Target/Target.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 const char *const LLDB_NT_OWNER_ANDROID = "Android"; 52 const char *const LLDB_NT_OWNER_CORE = "CORE"; 53 const char *const LLDB_NT_OWNER_LINUX = "LINUX"; 54 55 // ELF note type definitions 56 const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01; 57 const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4; 58 59 const elf_word LLDB_NT_GNU_ABI_TAG = 0x01; 60 const elf_word LLDB_NT_GNU_ABI_SIZE = 16; 61 62 const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03; 63 64 const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01; 65 const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4; 66 67 // GNU ABI note OS constants 68 const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00; 69 const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01; 70 const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02; 71 72 // LLDB_NT_OWNER_CORE and LLDB_NT_OWNER_LINUX note contants 73 #define NT_PRSTATUS 1 74 #define NT_PRFPREG 2 75 #define NT_PRPSINFO 3 76 #define NT_TASKSTRUCT 4 77 #define NT_AUXV 6 78 #define NT_SIGINFO 0x53494749 79 #define NT_FILE 0x46494c45 80 #define NT_PRXFPREG 0x46e62b7f 81 #define NT_PPC_VMX 0x100 82 #define NT_PPC_SPE 0x101 83 #define NT_PPC_VSX 0x102 84 #define NT_386_TLS 0x200 85 #define NT_386_IOPERM 0x201 86 #define NT_X86_XSTATE 0x202 87 #define NT_S390_HIGH_GPRS 0x300 88 #define NT_S390_TIMER 0x301 89 #define NT_S390_TODCMP 0x302 90 #define NT_S390_TODPREG 0x303 91 #define NT_S390_CTRS 0x304 92 #define NT_S390_PREFIX 0x305 93 #define NT_S390_LAST_BREAK 0x306 94 #define NT_S390_SYSTEM_CALL 0x307 95 #define NT_S390_TDB 0x308 96 #define NT_S390_VXRS_LOW 0x309 97 #define NT_S390_VXRS_HIGH 0x30a 98 #define NT_ARM_VFP 0x400 99 #define NT_ARM_TLS 0x401 100 #define NT_ARM_HW_BREAK 0x402 101 #define NT_ARM_HW_WATCH 0x403 102 #define NT_ARM_SYSTEM_CALL 0x404 103 #define NT_METAG_CBUF 0x500 104 #define NT_METAG_RPIPE 0x501 105 #define NT_METAG_TLS 0x502 106 107 //===----------------------------------------------------------------------===// 108 /// @class ELFRelocation 109 /// @brief Generic wrapper for ELFRel and ELFRela. 110 /// 111 /// This helper class allows us to parse both ELFRel and ELFRela relocation 112 /// entries in a generic manner. 113 class ELFRelocation 114 { 115 public: 116 117 /// Constructs an ELFRelocation entry with a personality as given by @p 118 /// type. 119 /// 120 /// @param type Either DT_REL or DT_RELA. Any other value is invalid. 121 ELFRelocation(unsigned type); 122 123 ~ELFRelocation(); 124 125 bool 126 Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); 127 128 static unsigned 129 RelocType32(const ELFRelocation &rel); 130 131 static unsigned 132 RelocType64(const ELFRelocation &rel); 133 134 static unsigned 135 RelocSymbol32(const ELFRelocation &rel); 136 137 static unsigned 138 RelocSymbol64(const ELFRelocation &rel); 139 140 static unsigned 141 RelocOffset32(const ELFRelocation &rel); 142 143 static unsigned 144 RelocOffset64(const ELFRelocation &rel); 145 146 static unsigned 147 RelocAddend32(const ELFRelocation &rel); 148 149 static unsigned 150 RelocAddend64(const ELFRelocation &rel); 151 152 private: 153 typedef llvm::PointerUnion<ELFRel*, ELFRela*> RelocUnion; 154 155 RelocUnion reloc; 156 }; 157 158 ELFRelocation::ELFRelocation(unsigned type) 159 { 160 if (type == DT_REL || type == SHT_REL) 161 reloc = new ELFRel(); 162 else if (type == DT_RELA || type == SHT_RELA) 163 reloc = new ELFRela(); 164 else { 165 assert(false && "unexpected relocation type"); 166 reloc = static_cast<ELFRel*>(NULL); 167 } 168 } 169 170 ELFRelocation::~ELFRelocation() 171 { 172 if (reloc.is<ELFRel*>()) 173 delete reloc.get<ELFRel*>(); 174 else 175 delete reloc.get<ELFRela*>(); 176 } 177 178 bool 179 ELFRelocation::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 180 { 181 if (reloc.is<ELFRel*>()) 182 return reloc.get<ELFRel*>()->Parse(data, offset); 183 else 184 return reloc.get<ELFRela*>()->Parse(data, offset); 185 } 186 187 unsigned 188 ELFRelocation::RelocType32(const ELFRelocation &rel) 189 { 190 if (rel.reloc.is<ELFRel*>()) 191 return ELFRel::RelocType32(*rel.reloc.get<ELFRel*>()); 192 else 193 return ELFRela::RelocType32(*rel.reloc.get<ELFRela*>()); 194 } 195 196 unsigned 197 ELFRelocation::RelocType64(const ELFRelocation &rel) 198 { 199 if (rel.reloc.is<ELFRel*>()) 200 return ELFRel::RelocType64(*rel.reloc.get<ELFRel*>()); 201 else 202 return ELFRela::RelocType64(*rel.reloc.get<ELFRela*>()); 203 } 204 205 unsigned 206 ELFRelocation::RelocSymbol32(const ELFRelocation &rel) 207 { 208 if (rel.reloc.is<ELFRel*>()) 209 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel*>()); 210 else 211 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela*>()); 212 } 213 214 unsigned 215 ELFRelocation::RelocSymbol64(const ELFRelocation &rel) 216 { 217 if (rel.reloc.is<ELFRel*>()) 218 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel*>()); 219 else 220 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela*>()); 221 } 222 223 unsigned 224 ELFRelocation::RelocOffset32(const ELFRelocation &rel) 225 { 226 if (rel.reloc.is<ELFRel*>()) 227 return rel.reloc.get<ELFRel*>()->r_offset; 228 else 229 return rel.reloc.get<ELFRela*>()->r_offset; 230 } 231 232 unsigned 233 ELFRelocation::RelocOffset64(const ELFRelocation &rel) 234 { 235 if (rel.reloc.is<ELFRel*>()) 236 return rel.reloc.get<ELFRel*>()->r_offset; 237 else 238 return rel.reloc.get<ELFRela*>()->r_offset; 239 } 240 241 unsigned 242 ELFRelocation::RelocAddend32(const ELFRelocation &rel) 243 { 244 if (rel.reloc.is<ELFRel*>()) 245 return 0; 246 else 247 return rel.reloc.get<ELFRela*>()->r_addend; 248 } 249 250 unsigned 251 ELFRelocation::RelocAddend64(const ELFRelocation &rel) 252 { 253 if (rel.reloc.is<ELFRel*>()) 254 return 0; 255 else 256 return rel.reloc.get<ELFRela*>()->r_addend; 257 } 258 259 } // end anonymous namespace 260 261 bool 262 ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) 263 { 264 // Read all fields. 265 if (data.GetU32(offset, &n_namesz, 3) == NULL) 266 return false; 267 268 // The name field is required to be nul-terminated, and n_namesz 269 // includes the terminating nul in observed implementations (contrary 270 // to the ELF-64 spec). A special case is needed for cores generated 271 // by some older Linux versions, which write a note named "CORE" 272 // without a nul terminator and n_namesz = 4. 273 if (n_namesz == 4) 274 { 275 char buf[4]; 276 if (data.ExtractBytes (*offset, 4, data.GetByteOrder(), buf) != 4) 277 return false; 278 if (strncmp (buf, "CORE", 4) == 0) 279 { 280 n_name = "CORE"; 281 *offset += 4; 282 return true; 283 } 284 } 285 286 const char *cstr = data.GetCStr(offset, llvm::RoundUpToAlignment (n_namesz, 4)); 287 if (cstr == NULL) 288 { 289 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS)); 290 if (log) 291 log->Printf("Failed to parse note name lacking nul terminator"); 292 293 return false; 294 } 295 n_name = cstr; 296 return true; 297 } 298 299 static uint32_t 300 kalimbaVariantFromElfFlags(const elf::elf_word e_flags) 301 { 302 const uint32_t dsp_rev = e_flags & 0xFF; 303 uint32_t kal_arch_variant = LLDB_INVALID_CPUTYPE; 304 switch(dsp_rev) 305 { 306 // TODO(mg11) Support more variants 307 case 10: 308 kal_arch_variant = llvm::Triple::KalimbaSubArch_v3; 309 break; 310 case 14: 311 kal_arch_variant = llvm::Triple::KalimbaSubArch_v4; 312 break; 313 case 17: 314 case 20: 315 kal_arch_variant = llvm::Triple::KalimbaSubArch_v5; 316 break; 317 default: 318 break; 319 } 320 return kal_arch_variant; 321 } 322 323 static uint32_t 324 mipsVariantFromElfFlags(const elf::elf_word e_flags, uint32_t endian) 325 { 326 const uint32_t mips_arch = e_flags & llvm::ELF::EF_MIPS_ARCH; 327 uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown; 328 329 switch (mips_arch) 330 { 331 case llvm::ELF::EF_MIPS_ARCH_1: 332 case llvm::ELF::EF_MIPS_ARCH_2: 333 case llvm::ELF::EF_MIPS_ARCH_3: 334 case llvm::ELF::EF_MIPS_ARCH_4: 335 case llvm::ELF::EF_MIPS_ARCH_5: 336 case llvm::ELF::EF_MIPS_ARCH_32: 337 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el : ArchSpec::eMIPSSubType_mips32; 338 case llvm::ELF::EF_MIPS_ARCH_32R2: 339 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el : ArchSpec::eMIPSSubType_mips32r2; 340 case llvm::ELF::EF_MIPS_ARCH_32R6: 341 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el : ArchSpec::eMIPSSubType_mips32r6; 342 case llvm::ELF::EF_MIPS_ARCH_64: 343 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el : ArchSpec::eMIPSSubType_mips64; 344 case llvm::ELF::EF_MIPS_ARCH_64R2: 345 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el : ArchSpec::eMIPSSubType_mips64r2; 346 case llvm::ELF::EF_MIPS_ARCH_64R6: 347 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el : ArchSpec::eMIPSSubType_mips64r6; 348 default: 349 break; 350 } 351 352 return arch_variant; 353 } 354 355 static uint32_t 356 subTypeFromElfHeader(const elf::ELFHeader& header) 357 { 358 if (header.e_machine == llvm::ELF::EM_MIPS) 359 return mipsVariantFromElfFlags (header.e_flags, 360 header.e_ident[EI_DATA]); 361 362 return 363 llvm::ELF::EM_CSR_KALIMBA == header.e_machine ? 364 kalimbaVariantFromElfFlags(header.e_flags) : 365 LLDB_INVALID_CPUTYPE; 366 } 367 368 //! The kalimba toolchain identifies a code section as being 369 //! one with the SHT_PROGBITS set in the section sh_type and the top 370 //! bit in the 32-bit address field set. 371 static lldb::SectionType 372 kalimbaSectionType( 373 const elf::ELFHeader& header, 374 const elf::ELFSectionHeader& sect_hdr) 375 { 376 if (llvm::ELF::EM_CSR_KALIMBA != header.e_machine) 377 { 378 return eSectionTypeOther; 379 } 380 381 if (llvm::ELF::SHT_NOBITS == sect_hdr.sh_type) 382 { 383 return eSectionTypeZeroFill; 384 } 385 386 if (llvm::ELF::SHT_PROGBITS == sect_hdr.sh_type) 387 { 388 const lldb::addr_t KAL_CODE_BIT = 1 << 31; 389 return KAL_CODE_BIT & sect_hdr.sh_addr ? 390 eSectionTypeCode : eSectionTypeData; 391 } 392 393 return eSectionTypeOther; 394 } 395 396 // Arbitrary constant used as UUID prefix for core files. 397 const uint32_t 398 ObjectFileELF::g_core_uuid_magic(0xE210C); 399 400 //------------------------------------------------------------------ 401 // Static methods. 402 //------------------------------------------------------------------ 403 void 404 ObjectFileELF::Initialize() 405 { 406 PluginManager::RegisterPlugin(GetPluginNameStatic(), 407 GetPluginDescriptionStatic(), 408 CreateInstance, 409 CreateMemoryInstance, 410 GetModuleSpecifications); 411 } 412 413 void 414 ObjectFileELF::Terminate() 415 { 416 PluginManager::UnregisterPlugin(CreateInstance); 417 } 418 419 lldb_private::ConstString 420 ObjectFileELF::GetPluginNameStatic() 421 { 422 static ConstString g_name("elf"); 423 return g_name; 424 } 425 426 const char * 427 ObjectFileELF::GetPluginDescriptionStatic() 428 { 429 return "ELF object file reader."; 430 } 431 432 ObjectFile * 433 ObjectFileELF::CreateInstance (const lldb::ModuleSP &module_sp, 434 DataBufferSP &data_sp, 435 lldb::offset_t data_offset, 436 const lldb_private::FileSpec* file, 437 lldb::offset_t file_offset, 438 lldb::offset_t length) 439 { 440 if (!data_sp) 441 { 442 data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length); 443 data_offset = 0; 444 } 445 446 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 447 { 448 const uint8_t *magic = data_sp->GetBytes() + data_offset; 449 if (ELFHeader::MagicBytesMatch(magic)) 450 { 451 // Update the data to contain the entire file if it doesn't already 452 if (data_sp->GetByteSize() < length) { 453 data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length); 454 data_offset = 0; 455 magic = data_sp->GetBytes(); 456 } 457 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 458 if (address_size == 4 || address_size == 8) 459 { 460 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, data_offset, file, file_offset, length)); 461 ArchSpec spec; 462 if (objfile_ap->GetArchitecture(spec) && 463 objfile_ap->SetModulesArchitecture(spec)) 464 return objfile_ap.release(); 465 } 466 } 467 } 468 return NULL; 469 } 470 471 472 ObjectFile* 473 ObjectFileELF::CreateMemoryInstance (const lldb::ModuleSP &module_sp, 474 DataBufferSP& data_sp, 475 const lldb::ProcessSP &process_sp, 476 lldb::addr_t header_addr) 477 { 478 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) 479 { 480 const uint8_t *magic = data_sp->GetBytes(); 481 if (ELFHeader::MagicBytesMatch(magic)) 482 { 483 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 484 if (address_size == 4 || address_size == 8) 485 { 486 std::auto_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, process_sp, header_addr)); 487 ArchSpec spec; 488 if (objfile_ap->GetArchitecture(spec) && 489 objfile_ap->SetModulesArchitecture(spec)) 490 return objfile_ap.release(); 491 } 492 } 493 } 494 return NULL; 495 } 496 497 bool 498 ObjectFileELF::MagicBytesMatch (DataBufferSP& data_sp, 499 lldb::addr_t data_offset, 500 lldb::addr_t data_length) 501 { 502 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) 503 { 504 const uint8_t *magic = data_sp->GetBytes() + data_offset; 505 return ELFHeader::MagicBytesMatch(magic); 506 } 507 return false; 508 } 509 510 /* 511 * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c 512 * 513 * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or 514 * code or tables extracted from it, as desired without restriction. 515 */ 516 static uint32_t 517 calc_crc32(uint32_t crc, const void *buf, size_t size) 518 { 519 static const uint32_t g_crc32_tab[] = 520 { 521 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 522 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 523 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 524 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 525 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 526 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 527 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 528 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 529 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 530 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 531 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 532 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 533 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 534 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 535 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 536 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 537 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 538 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 539 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 540 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 541 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 542 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 543 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 544 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 545 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 546 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 547 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 548 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 549 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 550 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 551 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 552 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 553 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 554 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 555 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 556 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 557 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 558 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 559 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 560 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 561 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 562 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 563 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 564 }; 565 const uint8_t *p = (const uint8_t *)buf; 566 567 crc = crc ^ ~0U; 568 while (size--) 569 crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); 570 return crc ^ ~0U; 571 } 572 573 static uint32_t 574 calc_gnu_debuglink_crc32(const void *buf, size_t size) 575 { 576 return calc_crc32(0U, buf, size); 577 } 578 579 uint32_t 580 ObjectFileELF::CalculateELFNotesSegmentsCRC32 (const ProgramHeaderColl& program_headers, 581 DataExtractor& object_data) 582 { 583 typedef ProgramHeaderCollConstIter Iter; 584 585 uint32_t core_notes_crc = 0; 586 587 for (Iter I = program_headers.begin(); I != program_headers.end(); ++I) 588 { 589 if (I->p_type == llvm::ELF::PT_NOTE) 590 { 591 const elf_off ph_offset = I->p_offset; 592 const size_t ph_size = I->p_filesz; 593 594 DataExtractor segment_data; 595 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) 596 { 597 // The ELF program header contained incorrect data, 598 // probably corefile is incomplete or corrupted. 599 break; 600 } 601 602 core_notes_crc = calc_crc32(core_notes_crc, 603 segment_data.GetDataStart(), 604 segment_data.GetByteSize()); 605 } 606 } 607 608 return core_notes_crc; 609 } 610 611 static const char* 612 OSABIAsCString (unsigned char osabi_byte) 613 { 614 #define _MAKE_OSABI_CASE(x) case x: return #x 615 switch (osabi_byte) 616 { 617 _MAKE_OSABI_CASE(ELFOSABI_NONE); 618 _MAKE_OSABI_CASE(ELFOSABI_HPUX); 619 _MAKE_OSABI_CASE(ELFOSABI_NETBSD); 620 _MAKE_OSABI_CASE(ELFOSABI_GNU); 621 _MAKE_OSABI_CASE(ELFOSABI_HURD); 622 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS); 623 _MAKE_OSABI_CASE(ELFOSABI_AIX); 624 _MAKE_OSABI_CASE(ELFOSABI_IRIX); 625 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD); 626 _MAKE_OSABI_CASE(ELFOSABI_TRU64); 627 _MAKE_OSABI_CASE(ELFOSABI_MODESTO); 628 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD); 629 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS); 630 _MAKE_OSABI_CASE(ELFOSABI_NSK); 631 _MAKE_OSABI_CASE(ELFOSABI_AROS); 632 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS); 633 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI); 634 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX); 635 _MAKE_OSABI_CASE(ELFOSABI_ARM); 636 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE); 637 default: 638 return "<unknown-osabi>"; 639 } 640 #undef _MAKE_OSABI_CASE 641 } 642 643 // 644 // WARNING : This function is being deprecated 645 // It's functionality has moved to ArchSpec::SetArchitecture 646 // This function is only being kept to validate the move. 647 // 648 // TODO : Remove this function 649 static bool 650 GetOsFromOSABI (unsigned char osabi_byte, llvm::Triple::OSType &ostype) 651 { 652 switch (osabi_byte) 653 { 654 case ELFOSABI_AIX: ostype = llvm::Triple::OSType::AIX; break; 655 case ELFOSABI_FREEBSD: ostype = llvm::Triple::OSType::FreeBSD; break; 656 case ELFOSABI_GNU: ostype = llvm::Triple::OSType::Linux; break; 657 case ELFOSABI_NETBSD: ostype = llvm::Triple::OSType::NetBSD; break; 658 case ELFOSABI_OPENBSD: ostype = llvm::Triple::OSType::OpenBSD; break; 659 case ELFOSABI_SOLARIS: ostype = llvm::Triple::OSType::Solaris; break; 660 default: 661 ostype = llvm::Triple::OSType::UnknownOS; 662 } 663 return ostype != llvm::Triple::OSType::UnknownOS; 664 } 665 666 size_t 667 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file, 668 lldb::DataBufferSP& data_sp, 669 lldb::offset_t data_offset, 670 lldb::offset_t file_offset, 671 lldb::offset_t length, 672 lldb_private::ModuleSpecList &specs) 673 { 674 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 675 676 const size_t initial_count = specs.GetSize(); 677 678 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) 679 { 680 DataExtractor data; 681 data.SetData(data_sp); 682 elf::ELFHeader header; 683 if (header.Parse(data, &data_offset)) 684 { 685 if (data_sp) 686 { 687 ModuleSpec spec (file); 688 689 const uint32_t sub_type = subTypeFromElfHeader(header); 690 spec.GetArchitecture().SetArchitecture(eArchTypeELF, 691 header.e_machine, 692 sub_type, 693 header.e_ident[EI_OSABI]); 694 695 if (spec.GetArchitecture().IsValid()) 696 { 697 llvm::Triple::OSType ostype; 698 llvm::Triple::VendorType vendor; 699 llvm::Triple::OSType spec_ostype = spec.GetArchitecture ().GetTriple ().getOS (); 700 701 if (log) 702 log->Printf ("ObjectFileELF::%s file '%s' module OSABI: %s", __FUNCTION__, file.GetPath ().c_str (), OSABIAsCString (header.e_ident[EI_OSABI])); 703 704 // SetArchitecture should have set the vendor to unknown 705 vendor = spec.GetArchitecture ().GetTriple ().getVendor (); 706 assert(vendor == llvm::Triple::UnknownVendor); 707 708 // 709 // Validate it is ok to remove GetOsFromOSABI 710 GetOsFromOSABI (header.e_ident[EI_OSABI], ostype); 711 assert(spec_ostype == ostype); 712 if (spec_ostype != llvm::Triple::OSType::UnknownOS) 713 { 714 if (log) 715 log->Printf ("ObjectFileELF::%s file '%s' set ELF module OS type from ELF header OSABI.", __FUNCTION__, file.GetPath ().c_str ()); 716 } 717 718 // Try to get the UUID from the section list. Usually that's at the end, so 719 // map the file in if we don't have it already. 720 size_t section_header_end = header.e_shoff + header.e_shnum * header.e_shentsize; 721 if (section_header_end > data_sp->GetByteSize()) 722 { 723 data_sp = file.MemoryMapFileContentsIfLocal (file_offset, section_header_end); 724 data.SetData(data_sp); 725 } 726 727 uint32_t gnu_debuglink_crc = 0; 728 std::string gnu_debuglink_file; 729 SectionHeaderColl section_headers; 730 lldb_private::UUID &uuid = spec.GetUUID(); 731 732 GetSectionHeaderInfo(section_headers, data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc, spec.GetArchitecture ()); 733 734 llvm::Triple &spec_triple = spec.GetArchitecture ().GetTriple (); 735 736 if (log) 737 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 ()); 738 739 if (!uuid.IsValid()) 740 { 741 uint32_t core_notes_crc = 0; 742 743 if (!gnu_debuglink_crc) 744 { 745 lldb_private::Timer scoped_timer (__PRETTY_FUNCTION__, 746 "Calculating module crc32 %s with size %" PRIu64 " KiB", 747 file.GetLastPathComponent().AsCString(), 748 (file.GetByteSize()-file_offset)/1024); 749 750 // For core files - which usually don't happen to have a gnu_debuglink, 751 // and are pretty bulky - calculating whole contents crc32 would be too much of luxury. 752 // Thus we will need to fallback to something simpler. 753 if (header.e_type == llvm::ELF::ET_CORE) 754 { 755 size_t program_headers_end = header.e_phoff + header.e_phnum * header.e_phentsize; 756 if (program_headers_end > data_sp->GetByteSize()) 757 { 758 data_sp = file.MemoryMapFileContentsIfLocal(file_offset, program_headers_end); 759 data.SetData(data_sp); 760 } 761 ProgramHeaderColl program_headers; 762 GetProgramHeaderInfo(program_headers, data, header); 763 764 size_t segment_data_end = 0; 765 for (ProgramHeaderCollConstIter I = program_headers.begin(); 766 I != program_headers.end(); ++I) 767 { 768 segment_data_end = std::max<unsigned long long> (I->p_offset + I->p_filesz, segment_data_end); 769 } 770 771 if (segment_data_end > data_sp->GetByteSize()) 772 { 773 data_sp = file.MemoryMapFileContentsIfLocal(file_offset, segment_data_end); 774 data.SetData(data_sp); 775 } 776 777 core_notes_crc = CalculateELFNotesSegmentsCRC32 (program_headers, data); 778 } 779 else 780 { 781 // Need to map entire file into memory to calculate the crc. 782 data_sp = file.MemoryMapFileContentsIfLocal (file_offset, SIZE_MAX); 783 data.SetData(data_sp); 784 gnu_debuglink_crc = calc_gnu_debuglink_crc32 (data.GetDataStart(), data.GetByteSize()); 785 } 786 } 787 if (gnu_debuglink_crc) 788 { 789 // Use 4 bytes of crc from the .gnu_debuglink section. 790 uint32_t uuidt[4] = { gnu_debuglink_crc, 0, 0, 0 }; 791 uuid.SetBytes (uuidt, sizeof(uuidt)); 792 } 793 else if (core_notes_crc) 794 { 795 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it look different form 796 // .gnu_debuglink crc followed by 4 bytes of note segments crc. 797 uint32_t uuidt[4] = { g_core_uuid_magic, core_notes_crc, 0, 0 }; 798 uuid.SetBytes (uuidt, sizeof(uuidt)); 799 } 800 } 801 802 specs.Append(spec); 803 } 804 } 805 } 806 } 807 808 return specs.GetSize() - initial_count; 809 } 810 811 //------------------------------------------------------------------ 812 // PluginInterface protocol 813 //------------------------------------------------------------------ 814 lldb_private::ConstString 815 ObjectFileELF::GetPluginName() 816 { 817 return GetPluginNameStatic(); 818 } 819 820 uint32_t 821 ObjectFileELF::GetPluginVersion() 822 { 823 return m_plugin_version; 824 } 825 //------------------------------------------------------------------ 826 // ObjectFile protocol 827 //------------------------------------------------------------------ 828 829 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 830 DataBufferSP& data_sp, 831 lldb::offset_t data_offset, 832 const FileSpec* file, 833 lldb::offset_t file_offset, 834 lldb::offset_t length) : 835 ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset), 836 m_header(), 837 m_uuid(), 838 m_gnu_debuglink_file(), 839 m_gnu_debuglink_crc(0), 840 m_program_headers(), 841 m_section_headers(), 842 m_dynamic_symbols(), 843 m_filespec_ap(), 844 m_entry_point_address(), 845 m_arch_spec() 846 { 847 if (file) 848 m_file = *file; 849 ::memset(&m_header, 0, sizeof(m_header)); 850 } 851 852 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 853 DataBufferSP& header_data_sp, 854 const lldb::ProcessSP &process_sp, 855 addr_t header_addr) : 856 ObjectFile(module_sp, process_sp, header_addr, header_data_sp), 857 m_header(), 858 m_uuid(), 859 m_gnu_debuglink_file(), 860 m_gnu_debuglink_crc(0), 861 m_program_headers(), 862 m_section_headers(), 863 m_dynamic_symbols(), 864 m_filespec_ap(), 865 m_entry_point_address(), 866 m_arch_spec() 867 { 868 ::memset(&m_header, 0, sizeof(m_header)); 869 } 870 871 ObjectFileELF::~ObjectFileELF() 872 { 873 } 874 875 bool 876 ObjectFileELF::IsExecutable() const 877 { 878 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0); 879 } 880 881 bool 882 ObjectFileELF::SetLoadAddress (Target &target, 883 lldb::addr_t value, 884 bool value_is_offset) 885 { 886 ModuleSP module_sp = GetModule(); 887 if (module_sp) 888 { 889 size_t num_loaded_sections = 0; 890 SectionList *section_list = GetSectionList (); 891 if (section_list) 892 { 893 if (!value_is_offset) 894 { 895 bool found_offset = false; 896 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) 897 { 898 const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i); 899 if (header == nullptr) 900 continue; 901 902 if (header->p_type != PT_LOAD || header->p_offset != 0) 903 continue; 904 905 value = value - header->p_vaddr; 906 found_offset = true; 907 break; 908 } 909 if (!found_offset) 910 return false; 911 } 912 913 const size_t num_sections = section_list->GetSize(); 914 size_t sect_idx = 0; 915 916 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) 917 { 918 // Iterate through the object file sections to find all 919 // of the sections that have SHF_ALLOC in their flag bits. 920 SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx)); 921 // if (section_sp && !section_sp->IsThreadSpecific()) 922 if (section_sp && section_sp->Test(SHF_ALLOC)) 923 { 924 lldb::addr_t load_addr = section_sp->GetFileAddress() + value; 925 926 // On 32-bit systems the load address have to fit into 4 bytes. The rest of 927 // the bytes are the overflow from the addition. 928 if (GetAddressByteSize() == 4) 929 load_addr &= 0xFFFFFFFF; 930 931 if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, load_addr)) 932 ++num_loaded_sections; 933 } 934 } 935 return num_loaded_sections > 0; 936 } 937 } 938 return false; 939 } 940 941 ByteOrder 942 ObjectFileELF::GetByteOrder() const 943 { 944 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB) 945 return eByteOrderBig; 946 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB) 947 return eByteOrderLittle; 948 return eByteOrderInvalid; 949 } 950 951 uint32_t 952 ObjectFileELF::GetAddressByteSize() const 953 { 954 return m_data.GetAddressByteSize(); 955 } 956 957 // Top 16 bits of the `Symbol` flags are available. 958 #define ARM_ELF_SYM_IS_THUMB (1 << 16) 959 960 AddressClass 961 ObjectFileELF::GetAddressClass (addr_t file_addr) 962 { 963 Symtab* symtab = GetSymtab(); 964 if (!symtab) 965 return eAddressClassUnknown; 966 967 // The address class is determined based on the symtab. Ask it from the object file what 968 // contains the symtab information. 969 ObjectFile* symtab_objfile = symtab->GetObjectFile(); 970 if (symtab_objfile != nullptr && symtab_objfile != this) 971 return symtab_objfile->GetAddressClass(file_addr); 972 973 auto res = ObjectFile::GetAddressClass (file_addr); 974 if (res != eAddressClassCode) 975 return res; 976 977 auto ub = m_address_class_map.upper_bound(file_addr); 978 if (ub == m_address_class_map.begin()) 979 { 980 // No entry in the address class map before the address. Return 981 // default address class for an address in a code section. 982 return eAddressClassCode; 983 } 984 985 // Move iterator to the address class entry preceding address 986 --ub; 987 988 return ub->second; 989 } 990 991 size_t 992 ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) 993 { 994 return std::distance(m_section_headers.begin(), I) + 1u; 995 } 996 997 size_t 998 ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const 999 { 1000 return std::distance(m_section_headers.begin(), I) + 1u; 1001 } 1002 1003 bool 1004 ObjectFileELF::ParseHeader() 1005 { 1006 lldb::offset_t offset = 0; 1007 if (!m_header.Parse(m_data, &offset)) 1008 return false; 1009 1010 if (!IsInMemory()) 1011 return true; 1012 1013 // For in memory object files m_data might not contain the full object file. Try to load it 1014 // until the end of the "Section header table" what is at the end of the ELF file. 1015 addr_t file_size = m_header.e_shoff + m_header.e_shnum * m_header.e_shentsize; 1016 if (m_data.GetByteSize() < file_size) 1017 { 1018 ProcessSP process_sp (m_process_wp.lock()); 1019 if (!process_sp) 1020 return false; 1021 1022 DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size); 1023 if (!data_sp) 1024 return false; 1025 m_data.SetData(data_sp, 0, file_size); 1026 } 1027 1028 return true; 1029 } 1030 1031 bool 1032 ObjectFileELF::GetUUID(lldb_private::UUID* uuid) 1033 { 1034 // Need to parse the section list to get the UUIDs, so make sure that's been done. 1035 if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile) 1036 return false; 1037 1038 if (m_uuid.IsValid()) 1039 { 1040 // We have the full build id uuid. 1041 *uuid = m_uuid; 1042 return true; 1043 } 1044 else if (GetType() == ObjectFile::eTypeCoreFile) 1045 { 1046 uint32_t core_notes_crc = 0; 1047 1048 if (!ParseProgramHeaders()) 1049 return false; 1050 1051 core_notes_crc = CalculateELFNotesSegmentsCRC32(m_program_headers, m_data); 1052 1053 if (core_notes_crc) 1054 { 1055 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it 1056 // look different form .gnu_debuglink crc - followed by 4 bytes of note 1057 // segments crc. 1058 uint32_t uuidt[4] = { g_core_uuid_magic, core_notes_crc, 0, 0 }; 1059 m_uuid.SetBytes (uuidt, sizeof(uuidt)); 1060 } 1061 } 1062 else 1063 { 1064 if (!m_gnu_debuglink_crc) 1065 m_gnu_debuglink_crc = calc_gnu_debuglink_crc32 (m_data.GetDataStart(), m_data.GetByteSize()); 1066 if (m_gnu_debuglink_crc) 1067 { 1068 // Use 4 bytes of crc from the .gnu_debuglink section. 1069 uint32_t uuidt[4] = { m_gnu_debuglink_crc, 0, 0, 0 }; 1070 m_uuid.SetBytes (uuidt, sizeof(uuidt)); 1071 } 1072 } 1073 1074 if (m_uuid.IsValid()) 1075 { 1076 *uuid = m_uuid; 1077 return true; 1078 } 1079 1080 return false; 1081 } 1082 1083 lldb_private::FileSpecList 1084 ObjectFileELF::GetDebugSymbolFilePaths() 1085 { 1086 FileSpecList file_spec_list; 1087 1088 if (!m_gnu_debuglink_file.empty()) 1089 { 1090 FileSpec file_spec (m_gnu_debuglink_file.c_str(), false); 1091 file_spec_list.Append (file_spec); 1092 } 1093 return file_spec_list; 1094 } 1095 1096 uint32_t 1097 ObjectFileELF::GetDependentModules(FileSpecList &files) 1098 { 1099 size_t num_modules = ParseDependentModules(); 1100 uint32_t num_specs = 0; 1101 1102 for (unsigned i = 0; i < num_modules; ++i) 1103 { 1104 if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i))) 1105 num_specs++; 1106 } 1107 1108 return num_specs; 1109 } 1110 1111 Address 1112 ObjectFileELF::GetImageInfoAddress(Target *target) 1113 { 1114 if (!ParseDynamicSymbols()) 1115 return Address(); 1116 1117 SectionList *section_list = GetSectionList(); 1118 if (!section_list) 1119 return Address(); 1120 1121 // Find the SHT_DYNAMIC (.dynamic) section. 1122 SectionSP dynsym_section_sp (section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true)); 1123 if (!dynsym_section_sp) 1124 return Address(); 1125 assert (dynsym_section_sp->GetObjectFile() == this); 1126 1127 user_id_t dynsym_id = dynsym_section_sp->GetID(); 1128 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id); 1129 if (!dynsym_hdr) 1130 return Address(); 1131 1132 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) 1133 { 1134 ELFDynamic &symbol = m_dynamic_symbols[i]; 1135 1136 if (symbol.d_tag == DT_DEBUG) 1137 { 1138 // Compute the offset as the number of previous entries plus the 1139 // size of d_tag. 1140 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 1141 return Address(dynsym_section_sp, offset); 1142 } 1143 // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP exists in non-PIE. 1144 else if ((symbol.d_tag == DT_MIPS_RLD_MAP || symbol.d_tag == DT_MIPS_RLD_MAP_REL) && target) 1145 { 1146 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 1147 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target); 1148 if (dyn_base == LLDB_INVALID_ADDRESS) 1149 return Address(); 1150 1151 Error error; 1152 if (symbol.d_tag == DT_MIPS_RLD_MAP) 1153 { 1154 // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer. 1155 Address addr; 1156 if (target->ReadPointerFromMemory(dyn_base + offset, false, error, addr)) 1157 return addr; 1158 } 1159 if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) 1160 { 1161 // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer, relative to the address of the tag. 1162 uint64_t rel_offset; 1163 rel_offset = target->ReadUnsignedIntegerFromMemory(dyn_base + offset, false, GetAddressByteSize(), UINT64_MAX, error); 1164 if (error.Success() && rel_offset != UINT64_MAX) 1165 { 1166 Address addr; 1167 addr_t debug_ptr_address = dyn_base + (offset - GetAddressByteSize()) + rel_offset; 1168 addr.SetOffset (debug_ptr_address); 1169 return addr; 1170 } 1171 } 1172 } 1173 } 1174 1175 return Address(); 1176 } 1177 1178 lldb_private::Address 1179 ObjectFileELF::GetEntryPointAddress () 1180 { 1181 if (m_entry_point_address.IsValid()) 1182 return m_entry_point_address; 1183 1184 if (!ParseHeader() || !IsExecutable()) 1185 return m_entry_point_address; 1186 1187 SectionList *section_list = GetSectionList(); 1188 addr_t offset = m_header.e_entry; 1189 1190 if (!section_list) 1191 m_entry_point_address.SetOffset(offset); 1192 else 1193 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list); 1194 return m_entry_point_address; 1195 } 1196 1197 //---------------------------------------------------------------------- 1198 // ParseDependentModules 1199 //---------------------------------------------------------------------- 1200 size_t 1201 ObjectFileELF::ParseDependentModules() 1202 { 1203 if (m_filespec_ap.get()) 1204 return m_filespec_ap->GetSize(); 1205 1206 m_filespec_ap.reset(new FileSpecList()); 1207 1208 if (!ParseSectionHeaders()) 1209 return 0; 1210 1211 SectionList *section_list = GetSectionList(); 1212 if (!section_list) 1213 return 0; 1214 1215 // Find the SHT_DYNAMIC section. 1216 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1217 if (!dynsym) 1218 return 0; 1219 assert (dynsym->GetObjectFile() == this); 1220 1221 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex (dynsym->GetID()); 1222 if (!header) 1223 return 0; 1224 // sh_link: section header index of string table used by entries in the section. 1225 Section *dynstr = section_list->FindSectionByID (header->sh_link + 1).get(); 1226 if (!dynstr) 1227 return 0; 1228 1229 DataExtractor dynsym_data; 1230 DataExtractor dynstr_data; 1231 if (ReadSectionData(dynsym, dynsym_data) && 1232 ReadSectionData(dynstr, dynstr_data)) 1233 { 1234 ELFDynamic symbol; 1235 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1236 lldb::offset_t offset = 0; 1237 1238 // The only type of entries we are concerned with are tagged DT_NEEDED, 1239 // yielding the name of a required library. 1240 while (offset < section_size) 1241 { 1242 if (!symbol.Parse(dynsym_data, &offset)) 1243 break; 1244 1245 if (symbol.d_tag != DT_NEEDED) 1246 continue; 1247 1248 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 1249 const char *lib_name = dynstr_data.PeekCStr(str_index); 1250 m_filespec_ap->Append(FileSpec(lib_name, true)); 1251 } 1252 } 1253 1254 return m_filespec_ap->GetSize(); 1255 } 1256 1257 //---------------------------------------------------------------------- 1258 // GetProgramHeaderInfo 1259 //---------------------------------------------------------------------- 1260 size_t 1261 ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers, 1262 DataExtractor &object_data, 1263 const ELFHeader &header) 1264 { 1265 // We have already parsed the program headers 1266 if (!program_headers.empty()) 1267 return program_headers.size(); 1268 1269 // If there are no program headers to read we are done. 1270 if (header.e_phnum == 0) 1271 return 0; 1272 1273 program_headers.resize(header.e_phnum); 1274 if (program_headers.size() != header.e_phnum) 1275 return 0; 1276 1277 const size_t ph_size = header.e_phnum * header.e_phentsize; 1278 const elf_off ph_offset = header.e_phoff; 1279 DataExtractor data; 1280 if (data.SetData(object_data, ph_offset, ph_size) != ph_size) 1281 return 0; 1282 1283 uint32_t idx; 1284 lldb::offset_t offset; 1285 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) 1286 { 1287 if (program_headers[idx].Parse(data, &offset) == false) 1288 break; 1289 } 1290 1291 if (idx < program_headers.size()) 1292 program_headers.resize(idx); 1293 1294 return program_headers.size(); 1295 1296 } 1297 1298 //---------------------------------------------------------------------- 1299 // ParseProgramHeaders 1300 //---------------------------------------------------------------------- 1301 size_t 1302 ObjectFileELF::ParseProgramHeaders() 1303 { 1304 return GetProgramHeaderInfo(m_program_headers, m_data, m_header); 1305 } 1306 1307 lldb_private::Error 1308 ObjectFileELF::RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid) 1309 { 1310 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1311 Error error; 1312 1313 lldb::offset_t offset = 0; 1314 1315 while (true) 1316 { 1317 // Parse the note header. If this fails, bail out. 1318 const lldb::offset_t note_offset = offset; 1319 ELFNote note = ELFNote(); 1320 if (!note.Parse(data, &offset)) 1321 { 1322 // We're done. 1323 return error; 1324 } 1325 1326 if (log) 1327 log->Printf ("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, __FUNCTION__, note.n_name.c_str (), note.n_type); 1328 1329 // Process FreeBSD ELF notes. 1330 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) && 1331 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) && 1332 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) 1333 { 1334 // Pull out the min version info. 1335 uint32_t version_info; 1336 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1337 { 1338 error.SetErrorString ("failed to read FreeBSD ABI note payload"); 1339 return error; 1340 } 1341 1342 // Convert the version info into a major/minor number. 1343 const uint32_t version_major = version_info / 100000; 1344 const uint32_t version_minor = (version_info / 1000) % 100; 1345 1346 char os_name[32]; 1347 snprintf (os_name, sizeof (os_name), "freebsd%" PRIu32 ".%" PRIu32, version_major, version_minor); 1348 1349 // Set the elf OS version to FreeBSD. Also clear the vendor. 1350 arch_spec.GetTriple ().setOSName (os_name); 1351 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1352 1353 if (log) 1354 log->Printf ("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_major, version_minor, static_cast<uint32_t> (version_info % 1000)); 1355 } 1356 // Process GNU ELF notes. 1357 else if (note.n_name == LLDB_NT_OWNER_GNU) 1358 { 1359 switch (note.n_type) 1360 { 1361 case LLDB_NT_GNU_ABI_TAG: 1362 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) 1363 { 1364 // Pull out the min OS version supporting the ABI. 1365 uint32_t version_info[4]; 1366 if (data.GetU32 (&offset, &version_info[0], note.n_descsz / 4) == nullptr) 1367 { 1368 error.SetErrorString ("failed to read GNU ABI note payload"); 1369 return error; 1370 } 1371 1372 // Set the OS per the OS field. 1373 switch (version_info[0]) 1374 { 1375 case LLDB_NT_GNU_ABI_OS_LINUX: 1376 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Linux); 1377 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1378 if (log) 1379 log->Printf ("ObjectFileELF::%s detected Linux, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1380 // 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. 1381 break; 1382 case LLDB_NT_GNU_ABI_OS_HURD: 1383 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::UnknownOS); 1384 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1385 if (log) 1386 log->Printf ("ObjectFileELF::%s detected Hurd (unsupported), min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1387 break; 1388 case LLDB_NT_GNU_ABI_OS_SOLARIS: 1389 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Solaris); 1390 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1391 if (log) 1392 log->Printf ("ObjectFileELF::%s detected Solaris, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1393 break; 1394 default: 1395 if (log) 1396 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]); 1397 break; 1398 } 1399 } 1400 break; 1401 1402 case LLDB_NT_GNU_BUILD_ID_TAG: 1403 // Only bother processing this if we don't already have the uuid set. 1404 if (!uuid.IsValid()) 1405 { 1406 // 16 bytes is UUID|MD5, 20 bytes is SHA1 1407 if ((note.n_descsz == 16 || note.n_descsz == 20)) 1408 { 1409 uint8_t uuidbuf[20]; 1410 if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == nullptr) 1411 { 1412 error.SetErrorString ("failed to read GNU_BUILD_ID note payload"); 1413 return error; 1414 } 1415 1416 // Save the build id as the UUID for the module. 1417 uuid.SetBytes (uuidbuf, note.n_descsz); 1418 } 1419 } 1420 break; 1421 } 1422 } 1423 // Process NetBSD ELF notes. 1424 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) && 1425 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) && 1426 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) 1427 { 1428 // Pull out the min version info. 1429 uint32_t version_info; 1430 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1431 { 1432 error.SetErrorString ("failed to read NetBSD ABI note payload"); 1433 return error; 1434 } 1435 1436 // Set the elf OS version to NetBSD. Also clear the vendor. 1437 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::NetBSD); 1438 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1439 1440 if (log) 1441 log->Printf ("ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32, __FUNCTION__, version_info); 1442 } 1443 // Process CSR kalimba notes 1444 else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) && 1445 (note.n_name == LLDB_NT_OWNER_CSR)) 1446 { 1447 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS); 1448 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR); 1449 1450 // TODO At some point the description string could be processed. 1451 // It could provide a steer towards the kalimba variant which 1452 // this ELF targets. 1453 if(note.n_descsz) 1454 { 1455 const char *cstr = data.GetCStr(&offset, llvm::RoundUpToAlignment (note.n_descsz, 4)); 1456 (void)cstr; 1457 } 1458 } 1459 else if (note.n_name == LLDB_NT_OWNER_ANDROID) 1460 { 1461 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1462 arch_spec.GetTriple().setEnvironment(llvm::Triple::EnvironmentType::Android); 1463 } 1464 else if (note.n_name == LLDB_NT_OWNER_LINUX) 1465 { 1466 // This is sometimes found in core files and usually contains extended register info 1467 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1468 } 1469 else if (note.n_name == LLDB_NT_OWNER_CORE) 1470 { 1471 // Parse the NT_FILE to look for stuff in paths to shared libraries 1472 // As the contents look like: 1473 // count = 0x000000000000000a (10) 1474 // page_size = 0x0000000000001000 (4096) 1475 // Index start end file_ofs path 1476 // ===== ------------------ ------------------ ------------------ ------------------------------------- 1477 // [ 0] 0x0000000000400000 0x0000000000401000 0x0000000000000000 /tmp/a.out 1478 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out 1479 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out 1480 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000 /lib/x86_64-linux-gnu/libc-2.19.so 1481 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-gnu/libc-2.19.so 1482 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so 1483 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64-linux-gnu/libc-2.19.so 1484 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so 1485 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64-linux-gnu/ld-2.19.so 1486 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so 1487 if (note.n_type == NT_FILE) 1488 { 1489 uint64_t count = data.GetU64(&offset); 1490 offset += 8 + 3*8*count; // Skip page size and all start/end/file_ofs 1491 for (size_t i=0; i<count; ++i) 1492 { 1493 llvm::StringRef path(data.GetCStr(&offset)); 1494 if (path.startswith("/lib/x86_64-linux-gnu")) 1495 { 1496 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1497 break; 1498 } 1499 } 1500 } 1501 } 1502 1503 // Calculate the offset of the next note just in case "offset" has been used 1504 // to poke at the contents of the note data 1505 offset = note_offset + note.GetByteSize(); 1506 } 1507 1508 return error; 1509 } 1510 1511 1512 //---------------------------------------------------------------------- 1513 // GetSectionHeaderInfo 1514 //---------------------------------------------------------------------- 1515 size_t 1516 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1517 lldb_private::DataExtractor &object_data, 1518 const elf::ELFHeader &header, 1519 lldb_private::UUID &uuid, 1520 std::string &gnu_debuglink_file, 1521 uint32_t &gnu_debuglink_crc, 1522 ArchSpec &arch_spec) 1523 { 1524 // Don't reparse the section headers if we already did that. 1525 if (!section_headers.empty()) 1526 return section_headers.size(); 1527 1528 // Only initialize the arch_spec to okay defaults if they're not already set. 1529 // We'll refine this with note data as we parse the notes. 1530 if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS) 1531 { 1532 llvm::Triple::OSType ostype; 1533 llvm::Triple::OSType spec_ostype; 1534 const uint32_t sub_type = subTypeFromElfHeader(header); 1535 arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]); 1536 // 1537 // Validate if it is ok to remove GetOsFromOSABI 1538 GetOsFromOSABI (header.e_ident[EI_OSABI], ostype); 1539 spec_ostype = arch_spec.GetTriple ().getOS (); 1540 assert(spec_ostype == ostype); 1541 } 1542 1543 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1544 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1545 { 1546 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) 1547 { 1548 case llvm::ELF::EF_MIPS_MICROMIPS: 1549 arch_spec.SetFlags (ArchSpec::eMIPSAse_micromips); 1550 break; 1551 case llvm::ELF::EF_MIPS_ARCH_ASE_M16: 1552 arch_spec.SetFlags (ArchSpec::eMIPSAse_mips16); 1553 break; 1554 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX: 1555 arch_spec.SetFlags (ArchSpec::eMIPSAse_mdmx); 1556 break; 1557 default: 1558 break; 1559 } 1560 } 1561 1562 // If there are no section headers we are done. 1563 if (header.e_shnum == 0) 1564 return 0; 1565 1566 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1567 1568 section_headers.resize(header.e_shnum); 1569 if (section_headers.size() != header.e_shnum) 1570 return 0; 1571 1572 const size_t sh_size = header.e_shnum * header.e_shentsize; 1573 const elf_off sh_offset = header.e_shoff; 1574 DataExtractor sh_data; 1575 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 1576 return 0; 1577 1578 uint32_t idx; 1579 lldb::offset_t offset; 1580 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1581 { 1582 if (section_headers[idx].Parse(sh_data, &offset) == false) 1583 break; 1584 } 1585 if (idx < section_headers.size()) 1586 section_headers.resize(idx); 1587 1588 const unsigned strtab_idx = header.e_shstrndx; 1589 if (strtab_idx && strtab_idx < section_headers.size()) 1590 { 1591 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1592 const size_t byte_size = sheader.sh_size; 1593 const Elf64_Off offset = sheader.sh_offset; 1594 lldb_private::DataExtractor shstr_data; 1595 1596 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 1597 { 1598 for (SectionHeaderCollIter I = section_headers.begin(); 1599 I != section_headers.end(); ++I) 1600 { 1601 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1602 const ELFSectionHeaderInfo &sheader = *I; 1603 const uint64_t section_size = sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1604 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1605 1606 I->section_name = name; 1607 1608 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1609 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1610 { 1611 uint32_t arch_flags = arch_spec.GetFlags (); 1612 DataExtractor data; 1613 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) 1614 { 1615 1616 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1617 { 1618 lldb::offset_t ase_offset = 12; // MIPS ABI Flags Version: 0 1619 arch_flags |= data.GetU32 (&ase_offset); 1620 } 1621 } 1622 // Settings appropriate ArchSpec ABI Flags 1623 if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1624 { 1625 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1626 } 1627 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI_O32) 1628 { 1629 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1630 } 1631 arch_spec.SetFlags (arch_flags); 1632 } 1633 1634 if (name == g_sect_name_gnu_debuglink) 1635 { 1636 DataExtractor data; 1637 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1638 { 1639 lldb::offset_t gnu_debuglink_offset = 0; 1640 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1641 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 1642 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1643 } 1644 } 1645 1646 // Process ELF note section entries. 1647 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1648 1649 // The section header ".note.android.ident" is stored as a 1650 // PROGBITS type header but it is actually a note header. 1651 static ConstString g_sect_name_android_ident (".note.android.ident"); 1652 if (!is_note_header && name == g_sect_name_android_ident) 1653 is_note_header = true; 1654 1655 if (is_note_header) 1656 { 1657 // Allow notes to refine module info. 1658 DataExtractor data; 1659 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1660 { 1661 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1662 if (error.Fail ()) 1663 { 1664 if (log) 1665 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1666 } 1667 } 1668 } 1669 } 1670 1671 // Make any unknown triple components to be unspecified unknowns. 1672 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor) 1673 arch_spec.GetTriple().setVendorName (llvm::StringRef()); 1674 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS) 1675 arch_spec.GetTriple().setOSName (llvm::StringRef()); 1676 1677 return section_headers.size(); 1678 } 1679 } 1680 1681 section_headers.clear(); 1682 return 0; 1683 } 1684 1685 size_t 1686 ObjectFileELF::GetProgramHeaderCount() 1687 { 1688 return ParseProgramHeaders(); 1689 } 1690 1691 const elf::ELFProgramHeader * 1692 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1693 { 1694 if (!id || !ParseProgramHeaders()) 1695 return NULL; 1696 1697 if (--id < m_program_headers.size()) 1698 return &m_program_headers[id]; 1699 1700 return NULL; 1701 } 1702 1703 DataExtractor 1704 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1705 { 1706 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1707 if (segment_header == NULL) 1708 return DataExtractor(); 1709 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1710 } 1711 1712 std::string 1713 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const 1714 { 1715 size_t pos = symbol_name.find('@'); 1716 return symbol_name.substr(0, pos).str(); 1717 } 1718 1719 //---------------------------------------------------------------------- 1720 // ParseSectionHeaders 1721 //---------------------------------------------------------------------- 1722 size_t 1723 ObjectFileELF::ParseSectionHeaders() 1724 { 1725 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec); 1726 } 1727 1728 const ObjectFileELF::ELFSectionHeaderInfo * 1729 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1730 { 1731 if (!id || !ParseSectionHeaders()) 1732 return NULL; 1733 1734 if (--id < m_section_headers.size()) 1735 return &m_section_headers[id]; 1736 1737 return NULL; 1738 } 1739 1740 lldb::user_id_t 1741 ObjectFileELF::GetSectionIndexByName(const char* name) 1742 { 1743 if (!name || !name[0] || !ParseSectionHeaders()) 1744 return 0; 1745 for (size_t i = 1; i < m_section_headers.size(); ++i) 1746 if (m_section_headers[i].section_name == ConstString(name)) 1747 return i; 1748 return 0; 1749 } 1750 1751 void 1752 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1753 { 1754 if (!m_sections_ap.get() && ParseSectionHeaders()) 1755 { 1756 m_sections_ap.reset(new SectionList()); 1757 1758 for (SectionHeaderCollIter I = m_section_headers.begin(); 1759 I != m_section_headers.end(); ++I) 1760 { 1761 const ELFSectionHeaderInfo &header = *I; 1762 1763 ConstString& name = I->section_name; 1764 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1765 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1766 1767 static ConstString g_sect_name_text (".text"); 1768 static ConstString g_sect_name_data (".data"); 1769 static ConstString g_sect_name_bss (".bss"); 1770 static ConstString g_sect_name_tdata (".tdata"); 1771 static ConstString g_sect_name_tbss (".tbss"); 1772 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1773 static ConstString g_sect_name_dwarf_debug_addr (".debug_addr"); 1774 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1775 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1776 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1777 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1778 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1779 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1780 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1781 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1782 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1783 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1784 static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets"); 1785 static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo"); 1786 static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo"); 1787 static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo"); 1788 static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo"); 1789 static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo"); 1790 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo"); 1791 static ConstString g_sect_name_eh_frame (".eh_frame"); 1792 static ConstString g_sect_name_arm_exidx (".ARM.exidx"); 1793 static ConstString g_sect_name_arm_extab (".ARM.extab"); 1794 static ConstString g_sect_name_go_symtab (".gosymtab"); 1795 1796 SectionType sect_type = eSectionTypeOther; 1797 1798 bool is_thread_specific = false; 1799 1800 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1801 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1802 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1803 else if (name == g_sect_name_tdata) 1804 { 1805 sect_type = eSectionTypeData; 1806 is_thread_specific = true; 1807 } 1808 else if (name == g_sect_name_tbss) 1809 { 1810 sect_type = eSectionTypeZeroFill; 1811 is_thread_specific = true; 1812 } 1813 // .debug_abbrev – Abbreviations used in the .debug_info section 1814 // .debug_aranges – Lookup table for mapping addresses to compilation units 1815 // .debug_frame – Call frame information 1816 // .debug_info – The core DWARF information section 1817 // .debug_line – Line number information 1818 // .debug_loc – Location lists used in DW_AT_location attributes 1819 // .debug_macinfo – Macro information 1820 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1821 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1822 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1823 // .debug_str – String table used in .debug_info 1824 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1825 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1826 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1827 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1828 else if (name == g_sect_name_dwarf_debug_addr) sect_type = eSectionTypeDWARFDebugAddr; 1829 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1830 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1831 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1832 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1833 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1834 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1835 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1836 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1837 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1838 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1839 else if (name == g_sect_name_dwarf_debug_str_offsets) sect_type = eSectionTypeDWARFDebugStrOffsets; 1840 else if (name == g_sect_name_dwarf_debug_abbrev_dwo) sect_type = eSectionTypeDWARFDebugAbbrev; 1841 else if (name == g_sect_name_dwarf_debug_info_dwo) sect_type = eSectionTypeDWARFDebugInfo; 1842 else if (name == g_sect_name_dwarf_debug_line_dwo) sect_type = eSectionTypeDWARFDebugLine; 1843 else if (name == g_sect_name_dwarf_debug_loc_dwo) sect_type = eSectionTypeDWARFDebugLoc; 1844 else if (name == g_sect_name_dwarf_debug_str_dwo) sect_type = eSectionTypeDWARFDebugStr; 1845 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets; 1846 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1847 else if (name == g_sect_name_arm_exidx) sect_type = eSectionTypeARMexidx; 1848 else if (name == g_sect_name_arm_extab) sect_type = eSectionTypeARMextab; 1849 else if (name == g_sect_name_go_symtab) sect_type = eSectionTypeGoSymtab; 1850 1851 switch (header.sh_type) 1852 { 1853 case SHT_SYMTAB: 1854 assert (sect_type == eSectionTypeOther); 1855 sect_type = eSectionTypeELFSymbolTable; 1856 break; 1857 case SHT_DYNSYM: 1858 assert (sect_type == eSectionTypeOther); 1859 sect_type = eSectionTypeELFDynamicSymbols; 1860 break; 1861 case SHT_RELA: 1862 case SHT_REL: 1863 assert (sect_type == eSectionTypeOther); 1864 sect_type = eSectionTypeELFRelocationEntries; 1865 break; 1866 case SHT_DYNAMIC: 1867 assert (sect_type == eSectionTypeOther); 1868 sect_type = eSectionTypeELFDynamicLinkInfo; 1869 break; 1870 } 1871 1872 if (eSectionTypeOther == sect_type) 1873 { 1874 // the kalimba toolchain assumes that ELF section names are free-form. It does 1875 // support linkscripts which (can) give rise to various arbitrarily named 1876 // sections being "Code" or "Data". 1877 sect_type = kalimbaSectionType(m_header, header); 1878 } 1879 1880 const uint32_t target_bytes_size = 1881 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type) ? 1882 m_arch_spec.GetDataByteSize() : 1883 eSectionTypeCode == sect_type ? 1884 m_arch_spec.GetCodeByteSize() : 1; 1885 1886 elf::elf_xword log2align = (header.sh_addralign==0) 1887 ? 0 1888 : llvm::Log2_64(header.sh_addralign); 1889 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1890 this, // ObjectFile to which this section belongs and should read section data from. 1891 SectionIndex(I), // Section ID. 1892 name, // Section name. 1893 sect_type, // Section type. 1894 header.sh_addr, // VM address. 1895 vm_size, // VM size in bytes of this section. 1896 header.sh_offset, // Offset of this section in the file. 1897 file_size, // Size of the section as found in the file. 1898 log2align, // Alignment of the section 1899 header.sh_flags, // Flags for this section. 1900 target_bytes_size));// Number of host bytes per target byte 1901 1902 if (is_thread_specific) 1903 section_sp->SetIsThreadSpecific (is_thread_specific); 1904 m_sections_ap->AddSection(section_sp); 1905 } 1906 } 1907 1908 if (m_sections_ap.get()) 1909 { 1910 if (GetType() == eTypeDebugInfo) 1911 { 1912 static const SectionType g_sections[] = 1913 { 1914 eSectionTypeDWARFDebugAbbrev, 1915 eSectionTypeDWARFDebugAddr, 1916 eSectionTypeDWARFDebugAranges, 1917 eSectionTypeDWARFDebugFrame, 1918 eSectionTypeDWARFDebugInfo, 1919 eSectionTypeDWARFDebugLine, 1920 eSectionTypeDWARFDebugLoc, 1921 eSectionTypeDWARFDebugMacInfo, 1922 eSectionTypeDWARFDebugPubNames, 1923 eSectionTypeDWARFDebugPubTypes, 1924 eSectionTypeDWARFDebugRanges, 1925 eSectionTypeDWARFDebugStr, 1926 eSectionTypeDWARFDebugStrOffsets, 1927 eSectionTypeELFSymbolTable, 1928 }; 1929 SectionList *elf_section_list = m_sections_ap.get(); 1930 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1931 { 1932 SectionType section_type = g_sections[idx]; 1933 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1934 if (section_sp) 1935 { 1936 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1937 if (module_section_sp) 1938 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1939 else 1940 unified_section_list.AddSection (section_sp); 1941 } 1942 } 1943 } 1944 else 1945 { 1946 unified_section_list = *m_sections_ap; 1947 } 1948 } 1949 } 1950 1951 // Find the arm/aarch64 mapping symbol character in the given symbol name. Mapping symbols have the 1952 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping symbol prefixed by 1953 // an arbitrary string because if a symbol prefix added to each symbol in the object file with 1954 // objcopy then the mapping symbols are also prefixed. 1955 static char 1956 FindArmAarch64MappingSymbol(const char* symbol_name) 1957 { 1958 if (!symbol_name) 1959 return '\0'; 1960 1961 const char* dollar_pos = ::strchr(symbol_name, '$'); 1962 if (!dollar_pos || dollar_pos[1] == '\0') 1963 return '\0'; 1964 1965 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 1966 return dollar_pos[1]; 1967 return '\0'; 1968 } 1969 1970 #define STO_MIPS_ISA (3 << 6) 1971 #define STO_MICROMIPS (2 << 6) 1972 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER) & STO_MIPS_ISA) == STO_MICROMIPS) 1973 1974 // private 1975 unsigned 1976 ObjectFileELF::ParseSymbols (Symtab *symtab, 1977 user_id_t start_id, 1978 SectionList *section_list, 1979 const size_t num_symbols, 1980 const DataExtractor &symtab_data, 1981 const DataExtractor &strtab_data) 1982 { 1983 ELFSymbol symbol; 1984 lldb::offset_t offset = 0; 1985 1986 static ConstString text_section_name(".text"); 1987 static ConstString init_section_name(".init"); 1988 static ConstString fini_section_name(".fini"); 1989 static ConstString ctors_section_name(".ctors"); 1990 static ConstString dtors_section_name(".dtors"); 1991 1992 static ConstString data_section_name(".data"); 1993 static ConstString rodata_section_name(".rodata"); 1994 static ConstString rodata1_section_name(".rodata1"); 1995 static ConstString data2_section_name(".data1"); 1996 static ConstString bss_section_name(".bss"); 1997 static ConstString opd_section_name(".opd"); // For ppc64 1998 1999 // On Android the oatdata and the oatexec symbols in system@framework@boot.oat covers the full 2000 // .text section what causes issues with displaying unusable symbol name to the user and very 2001 // slow unwinding speed because the instruction emulation based unwind plans try to emulate all 2002 // instructions in these symbols. Don't add these symbols to the symbol list as they have no 2003 // use for the debugger and they are causing a lot of trouble. 2004 // Filtering can't be restricted to Android because this special object file don't contain the 2005 // note section specifying the environment to Android but the custom extension and file name 2006 // makes it highly unlikely that this will collide with anything else. 2007 bool skip_oatdata_oatexec = m_file.GetFilename() == ConstString("system@framework@boot.oat"); 2008 2009 ArchSpec arch; 2010 GetArchitecture(arch); 2011 2012 // Local cache to avoid doing a FindSectionByName for each symbol. The "const char*" key must 2013 // came from a ConstString object so they can be compared by pointer 2014 std::unordered_map<const char*, lldb::SectionSP> section_name_to_section; 2015 2016 unsigned i; 2017 for (i = 0; i < num_symbols; ++i) 2018 { 2019 if (symbol.Parse(symtab_data, &offset) == false) 2020 break; 2021 2022 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2023 2024 // No need to add non-section symbols that have no names 2025 if (symbol.getType() != STT_SECTION && 2026 (symbol_name == NULL || symbol_name[0] == '\0')) 2027 continue; 2028 2029 // Skipping oatdata and oatexec sections if it is requested. See details above the 2030 // definition of skip_oatdata_oatexec for the reasons. 2031 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0)) 2032 continue; 2033 2034 SectionSP symbol_section_sp; 2035 SymbolType symbol_type = eSymbolTypeInvalid; 2036 Elf64_Half symbol_idx = symbol.st_shndx; 2037 2038 switch (symbol_idx) 2039 { 2040 case SHN_ABS: 2041 symbol_type = eSymbolTypeAbsolute; 2042 break; 2043 case SHN_UNDEF: 2044 symbol_type = eSymbolTypeUndefined; 2045 break; 2046 default: 2047 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 2048 break; 2049 } 2050 2051 // If a symbol is undefined do not process it further even if it has a STT type 2052 if (symbol_type != eSymbolTypeUndefined) 2053 { 2054 switch (symbol.getType()) 2055 { 2056 default: 2057 case STT_NOTYPE: 2058 // The symbol's type is not specified. 2059 break; 2060 2061 case STT_OBJECT: 2062 // The symbol is associated with a data object, such as a variable, 2063 // an array, etc. 2064 symbol_type = eSymbolTypeData; 2065 break; 2066 2067 case STT_FUNC: 2068 // The symbol is associated with a function or other executable code. 2069 symbol_type = eSymbolTypeCode; 2070 break; 2071 2072 case STT_SECTION: 2073 // The symbol is associated with a section. Symbol table entries of 2074 // this type exist primarily for relocation and normally have 2075 // STB_LOCAL binding. 2076 break; 2077 2078 case STT_FILE: 2079 // Conventionally, the symbol's name gives the name of the source 2080 // file associated with the object file. A file symbol has STB_LOCAL 2081 // binding, its section index is SHN_ABS, and it precedes the other 2082 // STB_LOCAL symbols for the file, if it is present. 2083 symbol_type = eSymbolTypeSourceFile; 2084 break; 2085 2086 case STT_GNU_IFUNC: 2087 // The symbol is associated with an indirect function. The actual 2088 // function will be resolved if it is referenced. 2089 symbol_type = eSymbolTypeResolver; 2090 break; 2091 } 2092 } 2093 2094 if (symbol_type == eSymbolTypeInvalid) 2095 { 2096 if (symbol_section_sp) 2097 { 2098 const ConstString §_name = symbol_section_sp->GetName(); 2099 if (sect_name == text_section_name || 2100 sect_name == init_section_name || 2101 sect_name == fini_section_name || 2102 sect_name == ctors_section_name || 2103 sect_name == dtors_section_name) 2104 { 2105 symbol_type = eSymbolTypeCode; 2106 } 2107 else if (sect_name == data_section_name || 2108 sect_name == data2_section_name || 2109 sect_name == rodata_section_name || 2110 sect_name == rodata1_section_name || 2111 sect_name == bss_section_name) 2112 { 2113 symbol_type = eSymbolTypeData; 2114 } 2115 } 2116 } 2117 2118 int64_t symbol_value_offset = 0; 2119 uint32_t additional_flags = 0; 2120 2121 if (arch.IsValid()) 2122 { 2123 if (arch.GetMachine() == llvm::Triple::arm) 2124 { 2125 if (symbol.getBinding() == STB_LOCAL) 2126 { 2127 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2128 if (symbol_type == eSymbolTypeCode) 2129 { 2130 switch (mapping_symbol) 2131 { 2132 case 'a': 2133 // $a[.<any>]* - marks an ARM instruction sequence 2134 m_address_class_map[symbol.st_value] = eAddressClassCode; 2135 break; 2136 case 'b': 2137 case 't': 2138 // $b[.<any>]* - marks a THUMB BL instruction sequence 2139 // $t[.<any>]* - marks a THUMB instruction sequence 2140 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2141 break; 2142 case 'd': 2143 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2144 m_address_class_map[symbol.st_value] = eAddressClassData; 2145 break; 2146 } 2147 } 2148 if (mapping_symbol) 2149 continue; 2150 } 2151 } 2152 else if (arch.GetMachine() == llvm::Triple::aarch64) 2153 { 2154 if (symbol.getBinding() == STB_LOCAL) 2155 { 2156 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2157 if (symbol_type == eSymbolTypeCode) 2158 { 2159 switch (mapping_symbol) 2160 { 2161 case 'x': 2162 // $x[.<any>]* - marks an A64 instruction sequence 2163 m_address_class_map[symbol.st_value] = eAddressClassCode; 2164 break; 2165 case 'd': 2166 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2167 m_address_class_map[symbol.st_value] = eAddressClassData; 2168 break; 2169 } 2170 } 2171 if (mapping_symbol) 2172 continue; 2173 } 2174 } 2175 2176 if (arch.GetMachine() == llvm::Triple::arm) 2177 { 2178 if (symbol_type == eSymbolTypeCode) 2179 { 2180 if (symbol.st_value & 1) 2181 { 2182 // Subtracting 1 from the address effectively unsets 2183 // the low order bit, which results in the address 2184 // actually pointing to the beginning of the symbol. 2185 // This delta will be used below in conjunction with 2186 // symbol.st_value to produce the final symbol_value 2187 // that we store in the symtab. 2188 symbol_value_offset = -1; 2189 additional_flags = ARM_ELF_SYM_IS_THUMB; 2190 m_address_class_map[symbol.st_value^1] = eAddressClassCodeAlternateISA; 2191 } 2192 else 2193 { 2194 // This address is ARM 2195 m_address_class_map[symbol.st_value] = eAddressClassCode; 2196 } 2197 } 2198 } 2199 2200 /* 2201 * MIPS: 2202 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for MIPS). 2203 * This allows processer to switch between microMIPS and MIPS without any need 2204 * for special mode-control register. However, apart from .debug_line, none of 2205 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use st_other 2206 * flag to check whether the symbol is microMIPS and then set the address class 2207 * accordingly. 2208 */ 2209 const llvm::Triple::ArchType llvm_arch = arch.GetMachine(); 2210 if (llvm_arch == llvm::Triple::mips || llvm_arch == llvm::Triple::mipsel 2211 || llvm_arch == llvm::Triple::mips64 || llvm_arch == llvm::Triple::mips64el) 2212 { 2213 if (IS_MICROMIPS(symbol.st_other)) 2214 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2215 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) 2216 { 2217 symbol.st_value = symbol.st_value & (~1ull); 2218 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2219 } 2220 else 2221 { 2222 if (symbol_type == eSymbolTypeCode) 2223 m_address_class_map[symbol.st_value] = eAddressClassCode; 2224 else if (symbol_type == eSymbolTypeData) 2225 m_address_class_map[symbol.st_value] = eAddressClassData; 2226 else 2227 m_address_class_map[symbol.st_value] = eAddressClassUnknown; 2228 } 2229 } 2230 } 2231 2232 // symbol_value_offset may contain 0 for ARM symbols or -1 for 2233 // THUMB symbols. See above for more details. 2234 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2235 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 2236 symbol_value -= symbol_section_sp->GetFileAddress(); 2237 2238 if (symbol_section_sp) 2239 { 2240 ModuleSP module_sp(GetModule()); 2241 if (module_sp) 2242 { 2243 SectionList *module_section_list = module_sp->GetSectionList(); 2244 if (module_section_list && module_section_list != section_list) 2245 { 2246 const ConstString §_name = symbol_section_sp->GetName(); 2247 auto section_it = section_name_to_section.find(sect_name.GetCString()); 2248 if (section_it == section_name_to_section.end()) 2249 section_it = section_name_to_section.emplace( 2250 sect_name.GetCString(), 2251 module_section_list->FindSectionByName (sect_name)).first; 2252 if (section_it->second && section_it->second->GetFileSize()) 2253 symbol_section_sp = section_it->second; 2254 } 2255 } 2256 } 2257 2258 bool is_global = symbol.getBinding() == STB_GLOBAL; 2259 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2260 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2261 2262 llvm::StringRef symbol_ref(symbol_name); 2263 2264 // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily. 2265 size_t version_pos = symbol_ref.find('@'); 2266 bool has_suffix = version_pos != llvm::StringRef::npos; 2267 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2268 Mangled mangled(ConstString(symbol_bare), is_mangled); 2269 2270 // Now append the suffix back to mangled and unmangled names. Only do it if the 2271 // demangling was successful (string is not empty). 2272 if (has_suffix) 2273 { 2274 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2275 2276 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2277 if (! mangled_name.empty()) 2278 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) ); 2279 2280 ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeUnknown); 2281 llvm::StringRef demangled_name = demangled.GetStringRef(); 2282 if (!demangled_name.empty()) 2283 mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) ); 2284 } 2285 2286 Symbol dc_symbol( 2287 i + start_id, // ID is the original symbol table index. 2288 mangled, 2289 symbol_type, // Type of this symbol 2290 is_global, // Is this globally visible? 2291 false, // Is this symbol debug info? 2292 false, // Is this symbol a trampoline? 2293 false, // Is this symbol artificial? 2294 AddressRange( 2295 symbol_section_sp, // Section in which this symbol is defined or null. 2296 symbol_value, // Offset in section or symbol value. 2297 symbol.st_size), // Size in bytes of this symbol. 2298 symbol.st_size != 0, // Size is valid if it is not 0 2299 has_suffix, // Contains linker annotations? 2300 flags); // Symbol flags. 2301 symtab->AddSymbol(dc_symbol); 2302 } 2303 return i; 2304 } 2305 2306 unsigned 2307 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 2308 { 2309 if (symtab->GetObjectFile() != this) 2310 { 2311 // If the symbol table section is owned by a different object file, have it do the 2312 // parsing. 2313 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2314 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 2315 } 2316 2317 // Get section list for this object file. 2318 SectionList *section_list = m_sections_ap.get(); 2319 if (!section_list) 2320 return 0; 2321 2322 user_id_t symtab_id = symtab->GetID(); 2323 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2324 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2325 symtab_hdr->sh_type == SHT_DYNSYM); 2326 2327 // sh_link: section header index of associated string table. 2328 // Section ID's are ones based. 2329 user_id_t strtab_id = symtab_hdr->sh_link + 1; 2330 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2331 2332 if (symtab && strtab) 2333 { 2334 assert (symtab->GetObjectFile() == this); 2335 assert (strtab->GetObjectFile() == this); 2336 2337 DataExtractor symtab_data; 2338 DataExtractor strtab_data; 2339 if (ReadSectionData(symtab, symtab_data) && 2340 ReadSectionData(strtab, strtab_data)) 2341 { 2342 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2343 2344 return ParseSymbols(symbol_table, start_id, section_list, 2345 num_symbols, symtab_data, strtab_data); 2346 } 2347 } 2348 2349 return 0; 2350 } 2351 2352 size_t 2353 ObjectFileELF::ParseDynamicSymbols() 2354 { 2355 if (m_dynamic_symbols.size()) 2356 return m_dynamic_symbols.size(); 2357 2358 SectionList *section_list = GetSectionList(); 2359 if (!section_list) 2360 return 0; 2361 2362 // Find the SHT_DYNAMIC section. 2363 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 2364 if (!dynsym) 2365 return 0; 2366 assert (dynsym->GetObjectFile() == this); 2367 2368 ELFDynamic symbol; 2369 DataExtractor dynsym_data; 2370 if (ReadSectionData(dynsym, dynsym_data)) 2371 { 2372 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2373 lldb::offset_t cursor = 0; 2374 2375 while (cursor < section_size) 2376 { 2377 if (!symbol.Parse(dynsym_data, &cursor)) 2378 break; 2379 2380 m_dynamic_symbols.push_back(symbol); 2381 } 2382 } 2383 2384 return m_dynamic_symbols.size(); 2385 } 2386 2387 const ELFDynamic * 2388 ObjectFileELF::FindDynamicSymbol(unsigned tag) 2389 { 2390 if (!ParseDynamicSymbols()) 2391 return NULL; 2392 2393 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2394 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2395 for ( ; I != E; ++I) 2396 { 2397 ELFDynamic *symbol = &*I; 2398 2399 if (symbol->d_tag == tag) 2400 return symbol; 2401 } 2402 2403 return NULL; 2404 } 2405 2406 unsigned 2407 ObjectFileELF::PLTRelocationType() 2408 { 2409 // DT_PLTREL 2410 // This member specifies the type of relocation entry to which the 2411 // procedure linkage table refers. The d_val member holds DT_REL or 2412 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2413 // must use the same relocation. 2414 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2415 2416 if (symbol) 2417 return symbol->d_val; 2418 2419 return 0; 2420 } 2421 2422 // Returns the size of the normal plt entries and the offset of the first normal plt entry. The 2423 // 0th entry in the plt table is usually a resolution entry which have different size in some 2424 // architectures then the rest of the plt entries. 2425 static std::pair<uint64_t, uint64_t> 2426 GetPltEntrySizeAndOffset(const ELFSectionHeader* rel_hdr, const ELFSectionHeader* plt_hdr) 2427 { 2428 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2429 2430 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 2431 // So round the entsize up by the alignment if addralign is set. 2432 elf_xword plt_entsize = plt_hdr->sh_addralign ? 2433 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 2434 2435 if (plt_entsize == 0) 2436 { 2437 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the size of the plt 2438 // entries based on the number of entries and the size of the plt section with the 2439 // assumption that the size of the 0th entry is at least as big as the size of the normal 2440 // entries and it isn't much bigger then that. 2441 if (plt_hdr->sh_addralign) 2442 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign; 2443 else 2444 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2445 } 2446 2447 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2448 2449 return std::make_pair(plt_entsize, plt_offset); 2450 } 2451 2452 static unsigned 2453 ParsePLTRelocations(Symtab *symbol_table, 2454 user_id_t start_id, 2455 unsigned rel_type, 2456 const ELFHeader *hdr, 2457 const ELFSectionHeader *rel_hdr, 2458 const ELFSectionHeader *plt_hdr, 2459 const ELFSectionHeader *sym_hdr, 2460 const lldb::SectionSP &plt_section_sp, 2461 DataExtractor &rel_data, 2462 DataExtractor &symtab_data, 2463 DataExtractor &strtab_data) 2464 { 2465 ELFRelocation rel(rel_type); 2466 ELFSymbol symbol; 2467 lldb::offset_t offset = 0; 2468 2469 uint64_t plt_offset, plt_entsize; 2470 std::tie(plt_entsize, plt_offset) = GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2471 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2472 2473 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2474 reloc_info_fn reloc_type; 2475 reloc_info_fn reloc_symbol; 2476 2477 if (hdr->Is32Bit()) 2478 { 2479 reloc_type = ELFRelocation::RelocType32; 2480 reloc_symbol = ELFRelocation::RelocSymbol32; 2481 } 2482 else 2483 { 2484 reloc_type = ELFRelocation::RelocType64; 2485 reloc_symbol = ELFRelocation::RelocSymbol64; 2486 } 2487 2488 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2489 unsigned i; 2490 for (i = 0; i < num_relocations; ++i) 2491 { 2492 if (rel.Parse(rel_data, &offset) == false) 2493 break; 2494 2495 if (reloc_type(rel) != slot_type) 2496 continue; 2497 2498 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2499 if (!symbol.Parse(symtab_data, &symbol_offset)) 2500 break; 2501 2502 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2503 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2504 uint64_t plt_index = plt_offset + i * plt_entsize; 2505 2506 Symbol jump_symbol( 2507 i + start_id, // Symbol table index 2508 symbol_name, // symbol name. 2509 is_mangled, // is the symbol name mangled? 2510 eSymbolTypeTrampoline, // Type of this symbol 2511 false, // Is this globally visible? 2512 false, // Is this symbol debug info? 2513 true, // Is this symbol a trampoline? 2514 true, // Is this symbol artificial? 2515 plt_section_sp, // Section in which this symbol is defined or null. 2516 plt_index, // Offset in section or symbol value. 2517 plt_entsize, // Size in bytes of this symbol. 2518 true, // Size is valid 2519 false, // Contains linker annotations? 2520 0); // Symbol flags. 2521 2522 symbol_table->AddSymbol(jump_symbol); 2523 } 2524 2525 return i; 2526 } 2527 2528 unsigned 2529 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2530 user_id_t start_id, 2531 const ELFSectionHeaderInfo *rel_hdr, 2532 user_id_t rel_id) 2533 { 2534 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2535 2536 // The link field points to the associated symbol table. The info field 2537 // points to the section holding the plt. 2538 user_id_t symtab_id = rel_hdr->sh_link; 2539 user_id_t plt_id = rel_hdr->sh_info; 2540 2541 // If the link field doesn't point to the appropriate symbol name table then 2542 // try to find it by name as some compiler don't fill in the link fields. 2543 if (!symtab_id) 2544 symtab_id = GetSectionIndexByName(".dynsym"); 2545 if (!plt_id) 2546 plt_id = GetSectionIndexByName(".plt"); 2547 2548 if (!symtab_id || !plt_id) 2549 return 0; 2550 2551 // Section ID's are ones based; 2552 symtab_id++; 2553 plt_id++; 2554 2555 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2556 if (!plt_hdr) 2557 return 0; 2558 2559 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2560 if (!sym_hdr) 2561 return 0; 2562 2563 SectionList *section_list = m_sections_ap.get(); 2564 if (!section_list) 2565 return 0; 2566 2567 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2568 if (!rel_section) 2569 return 0; 2570 2571 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2572 if (!plt_section_sp) 2573 return 0; 2574 2575 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2576 if (!symtab) 2577 return 0; 2578 2579 // sh_link points to associated string table. 2580 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2581 if (!strtab) 2582 return 0; 2583 2584 DataExtractor rel_data; 2585 if (!ReadSectionData(rel_section, rel_data)) 2586 return 0; 2587 2588 DataExtractor symtab_data; 2589 if (!ReadSectionData(symtab, symtab_data)) 2590 return 0; 2591 2592 DataExtractor strtab_data; 2593 if (!ReadSectionData(strtab, strtab_data)) 2594 return 0; 2595 2596 unsigned rel_type = PLTRelocationType(); 2597 if (!rel_type) 2598 return 0; 2599 2600 return ParsePLTRelocations (symbol_table, 2601 start_id, 2602 rel_type, 2603 &m_header, 2604 rel_hdr, 2605 plt_hdr, 2606 sym_hdr, 2607 plt_section_sp, 2608 rel_data, 2609 symtab_data, 2610 strtab_data); 2611 } 2612 2613 unsigned 2614 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2615 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2616 DataExtractor &rel_data, DataExtractor &symtab_data, 2617 DataExtractor &debug_data, Section* rel_section) 2618 { 2619 ELFRelocation rel(rel_hdr->sh_type); 2620 lldb::addr_t offset = 0; 2621 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2622 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2623 reloc_info_fn reloc_type; 2624 reloc_info_fn reloc_symbol; 2625 2626 if (hdr->Is32Bit()) 2627 { 2628 reloc_type = ELFRelocation::RelocType32; 2629 reloc_symbol = ELFRelocation::RelocSymbol32; 2630 } 2631 else 2632 { 2633 reloc_type = ELFRelocation::RelocType64; 2634 reloc_symbol = ELFRelocation::RelocSymbol64; 2635 } 2636 2637 for (unsigned i = 0; i < num_relocations; ++i) 2638 { 2639 if (rel.Parse(rel_data, &offset) == false) 2640 break; 2641 2642 Symbol* symbol = NULL; 2643 2644 if (hdr->Is32Bit()) 2645 { 2646 switch (reloc_type(rel)) { 2647 case R_386_32: 2648 case R_386_PC32: 2649 default: 2650 assert(false && "unexpected relocation type"); 2651 } 2652 } else { 2653 switch (reloc_type(rel)) { 2654 case R_X86_64_64: 2655 { 2656 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2657 if (symbol) 2658 { 2659 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2660 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2661 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2662 *dst = value + ELFRelocation::RelocAddend64(rel); 2663 } 2664 break; 2665 } 2666 case R_X86_64_32: 2667 case R_X86_64_32S: 2668 { 2669 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2670 if (symbol) 2671 { 2672 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2673 value += ELFRelocation::RelocAddend32(rel); 2674 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2675 (reloc_type(rel) == R_X86_64_32S && 2676 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2677 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2678 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2679 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2680 *dst = truncated_addr; 2681 } 2682 break; 2683 } 2684 case R_X86_64_PC32: 2685 default: 2686 assert(false && "unexpected relocation type"); 2687 } 2688 } 2689 } 2690 2691 return 0; 2692 } 2693 2694 unsigned 2695 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2696 { 2697 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2698 2699 // Parse in the section list if needed. 2700 SectionList *section_list = GetSectionList(); 2701 if (!section_list) 2702 return 0; 2703 2704 // Section ID's are ones based. 2705 user_id_t symtab_id = rel_hdr->sh_link + 1; 2706 user_id_t debug_id = rel_hdr->sh_info + 1; 2707 2708 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2709 if (!symtab_hdr) 2710 return 0; 2711 2712 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2713 if (!debug_hdr) 2714 return 0; 2715 2716 Section *rel = section_list->FindSectionByID(rel_id).get(); 2717 if (!rel) 2718 return 0; 2719 2720 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2721 if (!symtab) 2722 return 0; 2723 2724 Section *debug = section_list->FindSectionByID(debug_id).get(); 2725 if (!debug) 2726 return 0; 2727 2728 DataExtractor rel_data; 2729 DataExtractor symtab_data; 2730 DataExtractor debug_data; 2731 2732 if (ReadSectionData(rel, rel_data) && 2733 ReadSectionData(symtab, symtab_data) && 2734 ReadSectionData(debug, debug_data)) 2735 { 2736 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2737 rel_data, symtab_data, debug_data, debug); 2738 } 2739 2740 return 0; 2741 } 2742 2743 Symtab * 2744 ObjectFileELF::GetSymtab() 2745 { 2746 ModuleSP module_sp(GetModule()); 2747 if (!module_sp) 2748 return NULL; 2749 2750 // We always want to use the main object file so we (hopefully) only have one cached copy 2751 // of our symtab, dynamic sections, etc. 2752 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2753 if (module_obj_file && module_obj_file != this) 2754 return module_obj_file->GetSymtab(); 2755 2756 if (m_symtab_ap.get() == NULL) 2757 { 2758 SectionList *section_list = module_sp->GetSectionList(); 2759 if (!section_list) 2760 return NULL; 2761 2762 uint64_t symbol_id = 0; 2763 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2764 2765 // Sharable objects and dynamic executables usually have 2 distinct symbol 2766 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2767 // version of the symtab that only contains global symbols. The information found 2768 // in the dynsym is therefore also found in the symtab, while the reverse is not 2769 // necessarily true. 2770 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2771 if (!symtab) 2772 { 2773 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2774 // then use the dynsym section which should always be there. 2775 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2776 } 2777 if (symtab) 2778 { 2779 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile())); 2780 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2781 } 2782 2783 // DT_JMPREL 2784 // If present, this entry's d_ptr member holds the address of relocation 2785 // entries associated solely with the procedure linkage table. Separating 2786 // these relocation entries lets the dynamic linker ignore them during 2787 // process initialization, if lazy binding is enabled. If this entry is 2788 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2789 // also be present. 2790 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2791 if (symbol) 2792 { 2793 // Synthesize trampoline symbols to help navigate the PLT. 2794 addr_t addr = symbol->d_ptr; 2795 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2796 if (reloc_section) 2797 { 2798 user_id_t reloc_id = reloc_section->GetID(); 2799 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2800 assert(reloc_header); 2801 2802 if (m_symtab_ap == nullptr) 2803 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile())); 2804 2805 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2806 } 2807 } 2808 2809 // If we still don't have any symtab then create an empty instance to avoid do the section 2810 // lookup next time. 2811 if (m_symtab_ap == nullptr) 2812 m_symtab_ap.reset(new Symtab(this)); 2813 2814 m_symtab_ap->CalculateSymbolSizes(); 2815 } 2816 2817 for (SectionHeaderCollIter I = m_section_headers.begin(); 2818 I != m_section_headers.end(); ++I) 2819 { 2820 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2821 { 2822 if (CalculateType() == eTypeObjectFile) 2823 { 2824 const char *section_name = I->section_name.AsCString(""); 2825 if (strstr(section_name, ".rela.debug") || 2826 strstr(section_name, ".rel.debug")) 2827 { 2828 const ELFSectionHeader &reloc_header = *I; 2829 user_id_t reloc_id = SectionIndex(I); 2830 RelocateDebugSections(&reloc_header, reloc_id); 2831 } 2832 } 2833 } 2834 } 2835 return m_symtab_ap.get(); 2836 } 2837 2838 Symbol * 2839 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2840 { 2841 if (!m_symtab_ap.get()) 2842 return nullptr; // GetSymtab() should be called first. 2843 2844 const SectionList *section_list = GetSectionList(); 2845 if (!section_list) 2846 return nullptr; 2847 2848 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2849 { 2850 AddressRange range; 2851 if (eh_frame->GetAddressRange (so_addr, range)) 2852 { 2853 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2854 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2855 if (symbol) 2856 return symbol; 2857 2858 // Note that a (stripped) symbol won't be found by GetSymtab()... 2859 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2860 if (eh_sym_section_sp.get()) 2861 { 2862 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2863 addr_t offset = file_addr - section_base; 2864 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2865 2866 Symbol eh_symbol( 2867 symbol_id, // Symbol table index. 2868 "???", // Symbol name. 2869 false, // Is the symbol name mangled? 2870 eSymbolTypeCode, // Type of this symbol. 2871 true, // Is this globally visible? 2872 false, // Is this symbol debug info? 2873 false, // Is this symbol a trampoline? 2874 true, // Is this symbol artificial? 2875 eh_sym_section_sp, // Section in which this symbol is defined or null. 2876 offset, // Offset in section or symbol value. 2877 range.GetByteSize(), // Size in bytes of this symbol. 2878 true, // Size is valid. 2879 false, // Contains linker annotations? 2880 0); // Symbol flags. 2881 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2882 return m_symtab_ap->SymbolAtIndex(symbol_id); 2883 } 2884 } 2885 } 2886 return nullptr; 2887 } 2888 2889 2890 bool 2891 ObjectFileELF::IsStripped () 2892 { 2893 // TODO: determine this for ELF 2894 return false; 2895 } 2896 2897 //===----------------------------------------------------------------------===// 2898 // Dump 2899 // 2900 // Dump the specifics of the runtime file container (such as any headers 2901 // segments, sections, etc). 2902 //---------------------------------------------------------------------- 2903 void 2904 ObjectFileELF::Dump(Stream *s) 2905 { 2906 DumpELFHeader(s, m_header); 2907 s->EOL(); 2908 DumpELFProgramHeaders(s); 2909 s->EOL(); 2910 DumpELFSectionHeaders(s); 2911 s->EOL(); 2912 SectionList *section_list = GetSectionList(); 2913 if (section_list) 2914 section_list->Dump(s, NULL, true, UINT32_MAX); 2915 Symtab *symtab = GetSymtab(); 2916 if (symtab) 2917 symtab->Dump(s, NULL, eSortOrderNone); 2918 s->EOL(); 2919 DumpDependentModules(s); 2920 s->EOL(); 2921 } 2922 2923 //---------------------------------------------------------------------- 2924 // DumpELFHeader 2925 // 2926 // Dump the ELF header to the specified output stream 2927 //---------------------------------------------------------------------- 2928 void 2929 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2930 { 2931 s->PutCString("ELF Header\n"); 2932 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2933 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2934 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2935 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2936 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2937 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2938 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2939 2940 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2941 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2942 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2943 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2944 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2945 2946 s->Printf("e_type = 0x%4.4x ", header.e_type); 2947 DumpELFHeader_e_type(s, header.e_type); 2948 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2949 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2950 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2951 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2952 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2953 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2954 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2955 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2956 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2957 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2958 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2959 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2960 } 2961 2962 //---------------------------------------------------------------------- 2963 // DumpELFHeader_e_type 2964 // 2965 // Dump an token value for the ELF header member e_type 2966 //---------------------------------------------------------------------- 2967 void 2968 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2969 { 2970 switch (e_type) 2971 { 2972 case ET_NONE: *s << "ET_NONE"; break; 2973 case ET_REL: *s << "ET_REL"; break; 2974 case ET_EXEC: *s << "ET_EXEC"; break; 2975 case ET_DYN: *s << "ET_DYN"; break; 2976 case ET_CORE: *s << "ET_CORE"; break; 2977 default: 2978 break; 2979 } 2980 } 2981 2982 //---------------------------------------------------------------------- 2983 // DumpELFHeader_e_ident_EI_DATA 2984 // 2985 // Dump an token value for the ELF header member e_ident[EI_DATA] 2986 //---------------------------------------------------------------------- 2987 void 2988 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2989 { 2990 switch (ei_data) 2991 { 2992 case ELFDATANONE: *s << "ELFDATANONE"; break; 2993 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2994 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2995 default: 2996 break; 2997 } 2998 } 2999 3000 3001 //---------------------------------------------------------------------- 3002 // DumpELFProgramHeader 3003 // 3004 // Dump a single ELF program header to the specified output stream 3005 //---------------------------------------------------------------------- 3006 void 3007 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 3008 { 3009 DumpELFProgramHeader_p_type(s, ph.p_type); 3010 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 3011 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 3012 3013 DumpELFProgramHeader_p_flags(s, ph.p_flags); 3014 s->Printf(") %8.8" PRIx64, ph.p_align); 3015 } 3016 3017 //---------------------------------------------------------------------- 3018 // DumpELFProgramHeader_p_type 3019 // 3020 // Dump an token value for the ELF program header member p_type which 3021 // describes the type of the program header 3022 // ---------------------------------------------------------------------- 3023 void 3024 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 3025 { 3026 const int kStrWidth = 15; 3027 switch (p_type) 3028 { 3029 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 3030 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 3031 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 3032 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 3033 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 3034 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 3035 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 3036 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 3037 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 3038 default: 3039 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 3040 break; 3041 } 3042 } 3043 3044 3045 //---------------------------------------------------------------------- 3046 // DumpELFProgramHeader_p_flags 3047 // 3048 // Dump an token value for the ELF program header member p_flags 3049 //---------------------------------------------------------------------- 3050 void 3051 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 3052 { 3053 *s << ((p_flags & PF_X) ? "PF_X" : " ") 3054 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 3055 << ((p_flags & PF_W) ? "PF_W" : " ") 3056 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 3057 << ((p_flags & PF_R) ? "PF_R" : " "); 3058 } 3059 3060 //---------------------------------------------------------------------- 3061 // DumpELFProgramHeaders 3062 // 3063 // Dump all of the ELF program header to the specified output stream 3064 //---------------------------------------------------------------------- 3065 void 3066 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 3067 { 3068 if (!ParseProgramHeaders()) 3069 return; 3070 3071 s->PutCString("Program Headers\n"); 3072 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 3073 "p_filesz p_memsz p_flags p_align\n"); 3074 s->PutCString("==== --------------- -------- -------- -------- " 3075 "-------- -------- ------------------------- --------\n"); 3076 3077 uint32_t idx = 0; 3078 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 3079 I != m_program_headers.end(); ++I, ++idx) 3080 { 3081 s->Printf("[%2u] ", idx); 3082 ObjectFileELF::DumpELFProgramHeader(s, *I); 3083 s->EOL(); 3084 } 3085 } 3086 3087 //---------------------------------------------------------------------- 3088 // DumpELFSectionHeader 3089 // 3090 // Dump a single ELF section header to the specified output stream 3091 //---------------------------------------------------------------------- 3092 void 3093 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 3094 { 3095 s->Printf("%8.8x ", sh.sh_name); 3096 DumpELFSectionHeader_sh_type(s, sh.sh_type); 3097 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 3098 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 3099 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 3100 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 3101 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 3102 } 3103 3104 //---------------------------------------------------------------------- 3105 // DumpELFSectionHeader_sh_type 3106 // 3107 // Dump an token value for the ELF section header member sh_type which 3108 // describes the type of the section 3109 //---------------------------------------------------------------------- 3110 void 3111 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 3112 { 3113 const int kStrWidth = 12; 3114 switch (sh_type) 3115 { 3116 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 3117 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 3118 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 3119 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 3120 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 3121 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 3122 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 3123 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 3124 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 3125 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 3126 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 3127 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 3128 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 3129 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 3130 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 3131 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 3132 default: 3133 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 3134 break; 3135 } 3136 } 3137 3138 //---------------------------------------------------------------------- 3139 // DumpELFSectionHeader_sh_flags 3140 // 3141 // Dump an token value for the ELF section header member sh_flags 3142 //---------------------------------------------------------------------- 3143 void 3144 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 3145 { 3146 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3147 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3148 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3149 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3150 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3151 } 3152 3153 //---------------------------------------------------------------------- 3154 // DumpELFSectionHeaders 3155 // 3156 // Dump all of the ELF section header to the specified output stream 3157 //---------------------------------------------------------------------- 3158 void 3159 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 3160 { 3161 if (!ParseSectionHeaders()) 3162 return; 3163 3164 s->PutCString("Section Headers\n"); 3165 s->PutCString("IDX name type flags " 3166 "addr offset size link info addralgn " 3167 "entsize Name\n"); 3168 s->PutCString("==== -------- ------------ -------------------------------- " 3169 "-------- -------- -------- -------- -------- -------- " 3170 "-------- ====================\n"); 3171 3172 uint32_t idx = 0; 3173 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3174 I != m_section_headers.end(); ++I, ++idx) 3175 { 3176 s->Printf("[%2u] ", idx); 3177 ObjectFileELF::DumpELFSectionHeader(s, *I); 3178 const char* section_name = I->section_name.AsCString(""); 3179 if (section_name) 3180 *s << ' ' << section_name << "\n"; 3181 } 3182 } 3183 3184 void 3185 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 3186 { 3187 size_t num_modules = ParseDependentModules(); 3188 3189 if (num_modules > 0) 3190 { 3191 s->PutCString("Dependent Modules:\n"); 3192 for (unsigned i = 0; i < num_modules; ++i) 3193 { 3194 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 3195 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3196 } 3197 } 3198 } 3199 3200 bool 3201 ObjectFileELF::GetArchitecture (ArchSpec &arch) 3202 { 3203 if (!ParseHeader()) 3204 return false; 3205 3206 if (m_section_headers.empty()) 3207 { 3208 // Allow elf notes to be parsed which may affect the detected architecture. 3209 ParseSectionHeaders(); 3210 } 3211 3212 if (CalculateType() == eTypeCoreFile && m_arch_spec.TripleOSIsUnspecifiedUnknown()) 3213 { 3214 // Core files don't have section headers yet they have PT_NOTE program headers 3215 // that might shed more light on the architecture 3216 if (ParseProgramHeaders()) 3217 { 3218 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) 3219 { 3220 const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i); 3221 if (header && header->p_type == PT_NOTE && header->p_offset != 0 && header->p_filesz > 0) 3222 { 3223 DataExtractor data; 3224 if (data.SetData (m_data, header->p_offset, header->p_filesz) == header->p_filesz) 3225 { 3226 lldb_private::UUID uuid; 3227 RefineModuleDetailsFromNote (data, m_arch_spec, uuid); 3228 } 3229 } 3230 } 3231 } 3232 } 3233 arch = m_arch_spec; 3234 return true; 3235 } 3236 3237 ObjectFile::Type 3238 ObjectFileELF::CalculateType() 3239 { 3240 switch (m_header.e_type) 3241 { 3242 case llvm::ELF::ET_NONE: 3243 // 0 - No file type 3244 return eTypeUnknown; 3245 3246 case llvm::ELF::ET_REL: 3247 // 1 - Relocatable file 3248 return eTypeObjectFile; 3249 3250 case llvm::ELF::ET_EXEC: 3251 // 2 - Executable file 3252 return eTypeExecutable; 3253 3254 case llvm::ELF::ET_DYN: 3255 // 3 - Shared object file 3256 return eTypeSharedLibrary; 3257 3258 case ET_CORE: 3259 // 4 - Core file 3260 return eTypeCoreFile; 3261 3262 default: 3263 break; 3264 } 3265 return eTypeUnknown; 3266 } 3267 3268 ObjectFile::Strata 3269 ObjectFileELF::CalculateStrata() 3270 { 3271 switch (m_header.e_type) 3272 { 3273 case llvm::ELF::ET_NONE: 3274 // 0 - No file type 3275 return eStrataUnknown; 3276 3277 case llvm::ELF::ET_REL: 3278 // 1 - Relocatable file 3279 return eStrataUnknown; 3280 3281 case llvm::ELF::ET_EXEC: 3282 // 2 - Executable file 3283 // TODO: is there any way to detect that an executable is a kernel 3284 // related executable by inspecting the program headers, section 3285 // headers, symbols, or any other flag bits??? 3286 return eStrataUser; 3287 3288 case llvm::ELF::ET_DYN: 3289 // 3 - Shared object file 3290 // TODO: is there any way to detect that an shared library is a kernel 3291 // related executable by inspecting the program headers, section 3292 // headers, symbols, or any other flag bits??? 3293 return eStrataUnknown; 3294 3295 case ET_CORE: 3296 // 4 - Core file 3297 // TODO: is there any way to detect that an core file is a kernel 3298 // related executable by inspecting the program headers, section 3299 // headers, symbols, or any other flag bits??? 3300 return eStrataUnknown; 3301 3302 default: 3303 break; 3304 } 3305 return eStrataUnknown; 3306 } 3307 3308