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 #if 0 1565 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) 1566 arch_spec.GetTriple().setOSName(HostInfo::GetOSString().data()); 1567 #endif 1568 return 0; 1569 } 1570 1571 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1572 1573 section_headers.resize(header.e_shnum); 1574 if (section_headers.size() != header.e_shnum) 1575 return 0; 1576 1577 const size_t sh_size = header.e_shnum * header.e_shentsize; 1578 const elf_off sh_offset = header.e_shoff; 1579 DataExtractor sh_data; 1580 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 1581 return 0; 1582 1583 uint32_t idx; 1584 lldb::offset_t offset; 1585 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1586 { 1587 if (section_headers[idx].Parse(sh_data, &offset) == false) 1588 break; 1589 } 1590 if (idx < section_headers.size()) 1591 section_headers.resize(idx); 1592 1593 const unsigned strtab_idx = header.e_shstrndx; 1594 if (strtab_idx && strtab_idx < section_headers.size()) 1595 { 1596 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1597 const size_t byte_size = sheader.sh_size; 1598 const Elf64_Off offset = sheader.sh_offset; 1599 lldb_private::DataExtractor shstr_data; 1600 1601 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 1602 { 1603 for (SectionHeaderCollIter I = section_headers.begin(); 1604 I != section_headers.end(); ++I) 1605 { 1606 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1607 const ELFSectionHeaderInfo &sheader = *I; 1608 const uint64_t section_size = sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1609 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1610 1611 I->section_name = name; 1612 1613 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1614 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1615 { 1616 uint32_t arch_flags = arch_spec.GetFlags (); 1617 DataExtractor data; 1618 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) 1619 { 1620 1621 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1622 { 1623 lldb::offset_t ase_offset = 12; // MIPS ABI Flags Version: 0 1624 arch_flags |= data.GetU32 (&ase_offset); 1625 } 1626 } 1627 // Settings appropriate ArchSpec ABI Flags 1628 if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1629 { 1630 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1631 } 1632 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI_O32) 1633 { 1634 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1635 } 1636 arch_spec.SetFlags (arch_flags); 1637 } 1638 1639 if (name == g_sect_name_gnu_debuglink) 1640 { 1641 DataExtractor data; 1642 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1643 { 1644 lldb::offset_t gnu_debuglink_offset = 0; 1645 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1646 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 1647 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1648 } 1649 } 1650 1651 // Process ELF note section entries. 1652 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1653 1654 // The section header ".note.android.ident" is stored as a 1655 // PROGBITS type header but it is actually a note header. 1656 static ConstString g_sect_name_android_ident (".note.android.ident"); 1657 if (!is_note_header && name == g_sect_name_android_ident) 1658 is_note_header = true; 1659 1660 if (is_note_header) 1661 { 1662 // Allow notes to refine module info. 1663 DataExtractor data; 1664 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1665 { 1666 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1667 if (error.Fail ()) 1668 { 1669 if (log) 1670 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1671 } 1672 } 1673 } 1674 } 1675 1676 // Make any unknown triple components to be unspecified unknowns. 1677 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor) 1678 arch_spec.GetTriple().setVendorName (llvm::StringRef()); 1679 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS) 1680 arch_spec.GetTriple().setOSName (llvm::StringRef()); 1681 1682 return section_headers.size(); 1683 } 1684 } 1685 1686 section_headers.clear(); 1687 return 0; 1688 } 1689 1690 size_t 1691 ObjectFileELF::GetProgramHeaderCount() 1692 { 1693 return ParseProgramHeaders(); 1694 } 1695 1696 const elf::ELFProgramHeader * 1697 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1698 { 1699 if (!id || !ParseProgramHeaders()) 1700 return NULL; 1701 1702 if (--id < m_program_headers.size()) 1703 return &m_program_headers[id]; 1704 1705 return NULL; 1706 } 1707 1708 DataExtractor 1709 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1710 { 1711 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1712 if (segment_header == NULL) 1713 return DataExtractor(); 1714 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1715 } 1716 1717 std::string 1718 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const 1719 { 1720 size_t pos = symbol_name.find('@'); 1721 return symbol_name.substr(0, pos).str(); 1722 } 1723 1724 //---------------------------------------------------------------------- 1725 // ParseSectionHeaders 1726 //---------------------------------------------------------------------- 1727 size_t 1728 ObjectFileELF::ParseSectionHeaders() 1729 { 1730 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec); 1731 } 1732 1733 const ObjectFileELF::ELFSectionHeaderInfo * 1734 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1735 { 1736 if (!id || !ParseSectionHeaders()) 1737 return NULL; 1738 1739 if (--id < m_section_headers.size()) 1740 return &m_section_headers[id]; 1741 1742 return NULL; 1743 } 1744 1745 lldb::user_id_t 1746 ObjectFileELF::GetSectionIndexByName(const char* name) 1747 { 1748 if (!name || !name[0] || !ParseSectionHeaders()) 1749 return 0; 1750 for (size_t i = 1; i < m_section_headers.size(); ++i) 1751 if (m_section_headers[i].section_name == ConstString(name)) 1752 return i; 1753 return 0; 1754 } 1755 1756 void 1757 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1758 { 1759 if (!m_sections_ap.get() && ParseSectionHeaders()) 1760 { 1761 m_sections_ap.reset(new SectionList()); 1762 1763 for (SectionHeaderCollIter I = m_section_headers.begin(); 1764 I != m_section_headers.end(); ++I) 1765 { 1766 const ELFSectionHeaderInfo &header = *I; 1767 1768 ConstString& name = I->section_name; 1769 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1770 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1771 1772 static ConstString g_sect_name_text (".text"); 1773 static ConstString g_sect_name_data (".data"); 1774 static ConstString g_sect_name_bss (".bss"); 1775 static ConstString g_sect_name_tdata (".tdata"); 1776 static ConstString g_sect_name_tbss (".tbss"); 1777 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1778 static ConstString g_sect_name_dwarf_debug_addr (".debug_addr"); 1779 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1780 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1781 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1782 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1783 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1784 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1785 static ConstString g_sect_name_dwarf_debug_macro (".debug_macro"); 1786 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1787 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1788 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1789 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1790 static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets"); 1791 static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo"); 1792 static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo"); 1793 static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo"); 1794 static ConstString g_sect_name_dwarf_debug_macro_dwo (".debug_macro.dwo"); 1795 static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo"); 1796 static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo"); 1797 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo"); 1798 static ConstString g_sect_name_eh_frame (".eh_frame"); 1799 static ConstString g_sect_name_arm_exidx (".ARM.exidx"); 1800 static ConstString g_sect_name_arm_extab (".ARM.extab"); 1801 static ConstString g_sect_name_go_symtab (".gosymtab"); 1802 1803 SectionType sect_type = eSectionTypeOther; 1804 1805 bool is_thread_specific = false; 1806 1807 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1808 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1809 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1810 else if (name == g_sect_name_tdata) 1811 { 1812 sect_type = eSectionTypeData; 1813 is_thread_specific = true; 1814 } 1815 else if (name == g_sect_name_tbss) 1816 { 1817 sect_type = eSectionTypeZeroFill; 1818 is_thread_specific = true; 1819 } 1820 // .debug_abbrev – Abbreviations used in the .debug_info section 1821 // .debug_aranges – Lookup table for mapping addresses to compilation units 1822 // .debug_frame – Call frame information 1823 // .debug_info – The core DWARF information section 1824 // .debug_line – Line number information 1825 // .debug_loc – Location lists used in DW_AT_location attributes 1826 // .debug_macinfo – Macro information 1827 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1828 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1829 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1830 // .debug_str – String table used in .debug_info 1831 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1832 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1833 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1834 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1835 else if (name == g_sect_name_dwarf_debug_addr) sect_type = eSectionTypeDWARFDebugAddr; 1836 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1837 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1838 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1839 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1840 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1841 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1842 else if (name == g_sect_name_dwarf_debug_macro) sect_type = eSectionTypeDWARFDebugMacro; 1843 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1844 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1845 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1846 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1847 else if (name == g_sect_name_dwarf_debug_str_offsets) sect_type = eSectionTypeDWARFDebugStrOffsets; 1848 else if (name == g_sect_name_dwarf_debug_abbrev_dwo) sect_type = eSectionTypeDWARFDebugAbbrev; 1849 else if (name == g_sect_name_dwarf_debug_info_dwo) sect_type = eSectionTypeDWARFDebugInfo; 1850 else if (name == g_sect_name_dwarf_debug_line_dwo) sect_type = eSectionTypeDWARFDebugLine; 1851 else if (name == g_sect_name_dwarf_debug_macro_dwo) sect_type = eSectionTypeDWARFDebugMacro; 1852 else if (name == g_sect_name_dwarf_debug_loc_dwo) sect_type = eSectionTypeDWARFDebugLoc; 1853 else if (name == g_sect_name_dwarf_debug_str_dwo) sect_type = eSectionTypeDWARFDebugStr; 1854 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets; 1855 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1856 else if (name == g_sect_name_arm_exidx) sect_type = eSectionTypeARMexidx; 1857 else if (name == g_sect_name_arm_extab) sect_type = eSectionTypeARMextab; 1858 else if (name == g_sect_name_go_symtab) sect_type = eSectionTypeGoSymtab; 1859 1860 switch (header.sh_type) 1861 { 1862 case SHT_SYMTAB: 1863 assert (sect_type == eSectionTypeOther); 1864 sect_type = eSectionTypeELFSymbolTable; 1865 break; 1866 case SHT_DYNSYM: 1867 assert (sect_type == eSectionTypeOther); 1868 sect_type = eSectionTypeELFDynamicSymbols; 1869 break; 1870 case SHT_RELA: 1871 case SHT_REL: 1872 assert (sect_type == eSectionTypeOther); 1873 sect_type = eSectionTypeELFRelocationEntries; 1874 break; 1875 case SHT_DYNAMIC: 1876 assert (sect_type == eSectionTypeOther); 1877 sect_type = eSectionTypeELFDynamicLinkInfo; 1878 break; 1879 } 1880 1881 if (eSectionTypeOther == sect_type) 1882 { 1883 // the kalimba toolchain assumes that ELF section names are free-form. It does 1884 // support linkscripts which (can) give rise to various arbitrarily named 1885 // sections being "Code" or "Data". 1886 sect_type = kalimbaSectionType(m_header, header); 1887 } 1888 1889 const uint32_t target_bytes_size = 1890 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type) ? 1891 m_arch_spec.GetDataByteSize() : 1892 eSectionTypeCode == sect_type ? 1893 m_arch_spec.GetCodeByteSize() : 1; 1894 1895 elf::elf_xword log2align = (header.sh_addralign==0) 1896 ? 0 1897 : llvm::Log2_64(header.sh_addralign); 1898 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1899 this, // ObjectFile to which this section belongs and should read section data from. 1900 SectionIndex(I), // Section ID. 1901 name, // Section name. 1902 sect_type, // Section type. 1903 header.sh_addr, // VM address. 1904 vm_size, // VM size in bytes of this section. 1905 header.sh_offset, // Offset of this section in the file. 1906 file_size, // Size of the section as found in the file. 1907 log2align, // Alignment of the section 1908 header.sh_flags, // Flags for this section. 1909 target_bytes_size));// Number of host bytes per target byte 1910 1911 if (is_thread_specific) 1912 section_sp->SetIsThreadSpecific (is_thread_specific); 1913 m_sections_ap->AddSection(section_sp); 1914 } 1915 } 1916 1917 if (m_sections_ap.get()) 1918 { 1919 if (GetType() == eTypeDebugInfo) 1920 { 1921 static const SectionType g_sections[] = 1922 { 1923 eSectionTypeDWARFDebugAbbrev, 1924 eSectionTypeDWARFDebugAddr, 1925 eSectionTypeDWARFDebugAranges, 1926 eSectionTypeDWARFDebugFrame, 1927 eSectionTypeDWARFDebugInfo, 1928 eSectionTypeDWARFDebugLine, 1929 eSectionTypeDWARFDebugLoc, 1930 eSectionTypeDWARFDebugMacInfo, 1931 eSectionTypeDWARFDebugPubNames, 1932 eSectionTypeDWARFDebugPubTypes, 1933 eSectionTypeDWARFDebugRanges, 1934 eSectionTypeDWARFDebugStr, 1935 eSectionTypeDWARFDebugStrOffsets, 1936 eSectionTypeELFSymbolTable, 1937 }; 1938 SectionList *elf_section_list = m_sections_ap.get(); 1939 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1940 { 1941 SectionType section_type = g_sections[idx]; 1942 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1943 if (section_sp) 1944 { 1945 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1946 if (module_section_sp) 1947 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1948 else 1949 unified_section_list.AddSection (section_sp); 1950 } 1951 } 1952 } 1953 else 1954 { 1955 unified_section_list = *m_sections_ap; 1956 } 1957 } 1958 } 1959 1960 // Find the arm/aarch64 mapping symbol character in the given symbol name. Mapping symbols have the 1961 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping symbol prefixed by 1962 // an arbitrary string because if a symbol prefix added to each symbol in the object file with 1963 // objcopy then the mapping symbols are also prefixed. 1964 static char 1965 FindArmAarch64MappingSymbol(const char* symbol_name) 1966 { 1967 if (!symbol_name) 1968 return '\0'; 1969 1970 const char* dollar_pos = ::strchr(symbol_name, '$'); 1971 if (!dollar_pos || dollar_pos[1] == '\0') 1972 return '\0'; 1973 1974 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 1975 return dollar_pos[1]; 1976 return '\0'; 1977 } 1978 1979 #define STO_MIPS_ISA (3 << 6) 1980 #define STO_MICROMIPS (2 << 6) 1981 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER) & STO_MIPS_ISA) == STO_MICROMIPS) 1982 1983 // private 1984 unsigned 1985 ObjectFileELF::ParseSymbols (Symtab *symtab, 1986 user_id_t start_id, 1987 SectionList *section_list, 1988 const size_t num_symbols, 1989 const DataExtractor &symtab_data, 1990 const DataExtractor &strtab_data) 1991 { 1992 ELFSymbol symbol; 1993 lldb::offset_t offset = 0; 1994 1995 static ConstString text_section_name(".text"); 1996 static ConstString init_section_name(".init"); 1997 static ConstString fini_section_name(".fini"); 1998 static ConstString ctors_section_name(".ctors"); 1999 static ConstString dtors_section_name(".dtors"); 2000 2001 static ConstString data_section_name(".data"); 2002 static ConstString rodata_section_name(".rodata"); 2003 static ConstString rodata1_section_name(".rodata1"); 2004 static ConstString data2_section_name(".data1"); 2005 static ConstString bss_section_name(".bss"); 2006 static ConstString opd_section_name(".opd"); // For ppc64 2007 2008 // On Android the oatdata and the oatexec symbols in system@[email protected] covers the full 2009 // .text section what causes issues with displaying unusable symbol name to the user and very 2010 // slow unwinding speed because the instruction emulation based unwind plans try to emulate all 2011 // instructions in these symbols. Don't add these symbols to the symbol list as they have no 2012 // use for the debugger and they are causing a lot of trouble. 2013 // Filtering can't be restricted to Android because this special object file don't contain the 2014 // note section specifying the environment to Android but the custom extension and file name 2015 // makes it highly unlikely that this will collide with anything else. 2016 bool skip_oatdata_oatexec = m_file.GetFilename() == ConstString("system@[email protected]"); 2017 2018 ArchSpec arch; 2019 GetArchitecture(arch); 2020 2021 // Local cache to avoid doing a FindSectionByName for each symbol. The "const char*" key must 2022 // came from a ConstString object so they can be compared by pointer 2023 std::unordered_map<const char*, lldb::SectionSP> section_name_to_section; 2024 2025 unsigned i; 2026 for (i = 0; i < num_symbols; ++i) 2027 { 2028 if (symbol.Parse(symtab_data, &offset) == false) 2029 break; 2030 2031 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2032 2033 // No need to add non-section symbols that have no names 2034 if (symbol.getType() != STT_SECTION && 2035 (symbol_name == NULL || symbol_name[0] == '\0')) 2036 continue; 2037 2038 // Skipping oatdata and oatexec sections if it is requested. See details above the 2039 // definition of skip_oatdata_oatexec for the reasons. 2040 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0)) 2041 continue; 2042 2043 SectionSP symbol_section_sp; 2044 SymbolType symbol_type = eSymbolTypeInvalid; 2045 Elf64_Half symbol_idx = symbol.st_shndx; 2046 2047 switch (symbol_idx) 2048 { 2049 case SHN_ABS: 2050 symbol_type = eSymbolTypeAbsolute; 2051 break; 2052 case SHN_UNDEF: 2053 symbol_type = eSymbolTypeUndefined; 2054 break; 2055 default: 2056 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 2057 break; 2058 } 2059 2060 // If a symbol is undefined do not process it further even if it has a STT type 2061 if (symbol_type != eSymbolTypeUndefined) 2062 { 2063 switch (symbol.getType()) 2064 { 2065 default: 2066 case STT_NOTYPE: 2067 // The symbol's type is not specified. 2068 break; 2069 2070 case STT_OBJECT: 2071 // The symbol is associated with a data object, such as a variable, 2072 // an array, etc. 2073 symbol_type = eSymbolTypeData; 2074 break; 2075 2076 case STT_FUNC: 2077 // The symbol is associated with a function or other executable code. 2078 symbol_type = eSymbolTypeCode; 2079 break; 2080 2081 case STT_SECTION: 2082 // The symbol is associated with a section. Symbol table entries of 2083 // this type exist primarily for relocation and normally have 2084 // STB_LOCAL binding. 2085 break; 2086 2087 case STT_FILE: 2088 // Conventionally, the symbol's name gives the name of the source 2089 // file associated with the object file. A file symbol has STB_LOCAL 2090 // binding, its section index is SHN_ABS, and it precedes the other 2091 // STB_LOCAL symbols for the file, if it is present. 2092 symbol_type = eSymbolTypeSourceFile; 2093 break; 2094 2095 case STT_GNU_IFUNC: 2096 // The symbol is associated with an indirect function. The actual 2097 // function will be resolved if it is referenced. 2098 symbol_type = eSymbolTypeResolver; 2099 break; 2100 } 2101 } 2102 2103 if (symbol_type == eSymbolTypeInvalid) 2104 { 2105 if (symbol_section_sp) 2106 { 2107 const ConstString §_name = symbol_section_sp->GetName(); 2108 if (sect_name == text_section_name || 2109 sect_name == init_section_name || 2110 sect_name == fini_section_name || 2111 sect_name == ctors_section_name || 2112 sect_name == dtors_section_name) 2113 { 2114 symbol_type = eSymbolTypeCode; 2115 } 2116 else if (sect_name == data_section_name || 2117 sect_name == data2_section_name || 2118 sect_name == rodata_section_name || 2119 sect_name == rodata1_section_name || 2120 sect_name == bss_section_name) 2121 { 2122 symbol_type = eSymbolTypeData; 2123 } 2124 } 2125 } 2126 2127 int64_t symbol_value_offset = 0; 2128 uint32_t additional_flags = 0; 2129 2130 if (arch.IsValid()) 2131 { 2132 if (arch.GetMachine() == llvm::Triple::arm) 2133 { 2134 if (symbol.getBinding() == STB_LOCAL) 2135 { 2136 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2137 if (symbol_type == eSymbolTypeCode) 2138 { 2139 switch (mapping_symbol) 2140 { 2141 case 'a': 2142 // $a[.<any>]* - marks an ARM instruction sequence 2143 m_address_class_map[symbol.st_value] = eAddressClassCode; 2144 break; 2145 case 'b': 2146 case 't': 2147 // $b[.<any>]* - marks a THUMB BL instruction sequence 2148 // $t[.<any>]* - marks a THUMB instruction sequence 2149 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2150 break; 2151 case 'd': 2152 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2153 m_address_class_map[symbol.st_value] = eAddressClassData; 2154 break; 2155 } 2156 } 2157 if (mapping_symbol) 2158 continue; 2159 } 2160 } 2161 else if (arch.GetMachine() == llvm::Triple::aarch64) 2162 { 2163 if (symbol.getBinding() == STB_LOCAL) 2164 { 2165 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2166 if (symbol_type == eSymbolTypeCode) 2167 { 2168 switch (mapping_symbol) 2169 { 2170 case 'x': 2171 // $x[.<any>]* - marks an A64 instruction sequence 2172 m_address_class_map[symbol.st_value] = eAddressClassCode; 2173 break; 2174 case 'd': 2175 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2176 m_address_class_map[symbol.st_value] = eAddressClassData; 2177 break; 2178 } 2179 } 2180 if (mapping_symbol) 2181 continue; 2182 } 2183 } 2184 2185 if (arch.GetMachine() == llvm::Triple::arm) 2186 { 2187 if (symbol_type == eSymbolTypeCode) 2188 { 2189 if (symbol.st_value & 1) 2190 { 2191 // Subtracting 1 from the address effectively unsets 2192 // the low order bit, which results in the address 2193 // actually pointing to the beginning of the symbol. 2194 // This delta will be used below in conjunction with 2195 // symbol.st_value to produce the final symbol_value 2196 // that we store in the symtab. 2197 symbol_value_offset = -1; 2198 additional_flags = ARM_ELF_SYM_IS_THUMB; 2199 m_address_class_map[symbol.st_value^1] = eAddressClassCodeAlternateISA; 2200 } 2201 else 2202 { 2203 // This address is ARM 2204 m_address_class_map[symbol.st_value] = eAddressClassCode; 2205 } 2206 } 2207 } 2208 2209 /* 2210 * MIPS: 2211 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for MIPS). 2212 * This allows processer to switch between microMIPS and MIPS without any need 2213 * for special mode-control register. However, apart from .debug_line, none of 2214 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use st_other 2215 * flag to check whether the symbol is microMIPS and then set the address class 2216 * accordingly. 2217 */ 2218 const llvm::Triple::ArchType llvm_arch = arch.GetMachine(); 2219 if (llvm_arch == llvm::Triple::mips || llvm_arch == llvm::Triple::mipsel 2220 || llvm_arch == llvm::Triple::mips64 || llvm_arch == llvm::Triple::mips64el) 2221 { 2222 if (IS_MICROMIPS(symbol.st_other)) 2223 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2224 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) 2225 { 2226 symbol.st_value = symbol.st_value & (~1ull); 2227 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2228 } 2229 else 2230 { 2231 if (symbol_type == eSymbolTypeCode) 2232 m_address_class_map[symbol.st_value] = eAddressClassCode; 2233 else if (symbol_type == eSymbolTypeData) 2234 m_address_class_map[symbol.st_value] = eAddressClassData; 2235 else 2236 m_address_class_map[symbol.st_value] = eAddressClassUnknown; 2237 } 2238 } 2239 } 2240 2241 // symbol_value_offset may contain 0 for ARM symbols or -1 for 2242 // THUMB symbols. See above for more details. 2243 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2244 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 2245 symbol_value -= symbol_section_sp->GetFileAddress(); 2246 2247 if (symbol_section_sp) 2248 { 2249 ModuleSP module_sp(GetModule()); 2250 if (module_sp) 2251 { 2252 SectionList *module_section_list = module_sp->GetSectionList(); 2253 if (module_section_list && module_section_list != section_list) 2254 { 2255 const ConstString §_name = symbol_section_sp->GetName(); 2256 auto section_it = section_name_to_section.find(sect_name.GetCString()); 2257 if (section_it == section_name_to_section.end()) 2258 section_it = section_name_to_section.emplace( 2259 sect_name.GetCString(), 2260 module_section_list->FindSectionByName (sect_name)).first; 2261 if (section_it->second && section_it->second->GetFileSize()) 2262 symbol_section_sp = section_it->second; 2263 } 2264 } 2265 } 2266 2267 bool is_global = symbol.getBinding() == STB_GLOBAL; 2268 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2269 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2270 2271 llvm::StringRef symbol_ref(symbol_name); 2272 2273 // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily. 2274 size_t version_pos = symbol_ref.find('@'); 2275 bool has_suffix = version_pos != llvm::StringRef::npos; 2276 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2277 Mangled mangled(ConstString(symbol_bare), is_mangled); 2278 2279 // Now append the suffix back to mangled and unmangled names. Only do it if the 2280 // demangling was successful (string is not empty). 2281 if (has_suffix) 2282 { 2283 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2284 2285 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2286 if (! mangled_name.empty()) 2287 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) ); 2288 2289 ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeUnknown); 2290 llvm::StringRef demangled_name = demangled.GetStringRef(); 2291 if (!demangled_name.empty()) 2292 mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) ); 2293 } 2294 2295 Symbol dc_symbol( 2296 i + start_id, // ID is the original symbol table index. 2297 mangled, 2298 symbol_type, // Type of this symbol 2299 is_global, // Is this globally visible? 2300 false, // Is this symbol debug info? 2301 false, // Is this symbol a trampoline? 2302 false, // Is this symbol artificial? 2303 AddressRange( 2304 symbol_section_sp, // Section in which this symbol is defined or null. 2305 symbol_value, // Offset in section or symbol value. 2306 symbol.st_size), // Size in bytes of this symbol. 2307 symbol.st_size != 0, // Size is valid if it is not 0 2308 has_suffix, // Contains linker annotations? 2309 flags); // Symbol flags. 2310 symtab->AddSymbol(dc_symbol); 2311 } 2312 return i; 2313 } 2314 2315 unsigned 2316 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 2317 { 2318 if (symtab->GetObjectFile() != this) 2319 { 2320 // If the symbol table section is owned by a different object file, have it do the 2321 // parsing. 2322 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2323 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 2324 } 2325 2326 // Get section list for this object file. 2327 SectionList *section_list = m_sections_ap.get(); 2328 if (!section_list) 2329 return 0; 2330 2331 user_id_t symtab_id = symtab->GetID(); 2332 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2333 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2334 symtab_hdr->sh_type == SHT_DYNSYM); 2335 2336 // sh_link: section header index of associated string table. 2337 // Section ID's are ones based. 2338 user_id_t strtab_id = symtab_hdr->sh_link + 1; 2339 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2340 2341 if (symtab && strtab) 2342 { 2343 assert (symtab->GetObjectFile() == this); 2344 assert (strtab->GetObjectFile() == this); 2345 2346 DataExtractor symtab_data; 2347 DataExtractor strtab_data; 2348 if (ReadSectionData(symtab, symtab_data) && 2349 ReadSectionData(strtab, strtab_data)) 2350 { 2351 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2352 2353 return ParseSymbols(symbol_table, start_id, section_list, 2354 num_symbols, symtab_data, strtab_data); 2355 } 2356 } 2357 2358 return 0; 2359 } 2360 2361 size_t 2362 ObjectFileELF::ParseDynamicSymbols() 2363 { 2364 if (m_dynamic_symbols.size()) 2365 return m_dynamic_symbols.size(); 2366 2367 SectionList *section_list = GetSectionList(); 2368 if (!section_list) 2369 return 0; 2370 2371 // Find the SHT_DYNAMIC section. 2372 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 2373 if (!dynsym) 2374 return 0; 2375 assert (dynsym->GetObjectFile() == this); 2376 2377 ELFDynamic symbol; 2378 DataExtractor dynsym_data; 2379 if (ReadSectionData(dynsym, dynsym_data)) 2380 { 2381 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2382 lldb::offset_t cursor = 0; 2383 2384 while (cursor < section_size) 2385 { 2386 if (!symbol.Parse(dynsym_data, &cursor)) 2387 break; 2388 2389 m_dynamic_symbols.push_back(symbol); 2390 } 2391 } 2392 2393 return m_dynamic_symbols.size(); 2394 } 2395 2396 const ELFDynamic * 2397 ObjectFileELF::FindDynamicSymbol(unsigned tag) 2398 { 2399 if (!ParseDynamicSymbols()) 2400 return NULL; 2401 2402 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2403 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2404 for ( ; I != E; ++I) 2405 { 2406 ELFDynamic *symbol = &*I; 2407 2408 if (symbol->d_tag == tag) 2409 return symbol; 2410 } 2411 2412 return NULL; 2413 } 2414 2415 unsigned 2416 ObjectFileELF::PLTRelocationType() 2417 { 2418 // DT_PLTREL 2419 // This member specifies the type of relocation entry to which the 2420 // procedure linkage table refers. The d_val member holds DT_REL or 2421 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2422 // must use the same relocation. 2423 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2424 2425 if (symbol) 2426 return symbol->d_val; 2427 2428 return 0; 2429 } 2430 2431 // Returns the size of the normal plt entries and the offset of the first normal plt entry. The 2432 // 0th entry in the plt table is usually a resolution entry which have different size in some 2433 // architectures then the rest of the plt entries. 2434 static std::pair<uint64_t, uint64_t> 2435 GetPltEntrySizeAndOffset(const ELFSectionHeader* rel_hdr, const ELFSectionHeader* plt_hdr) 2436 { 2437 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2438 2439 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 2440 // So round the entsize up by the alignment if addralign is set. 2441 elf_xword plt_entsize = plt_hdr->sh_addralign ? 2442 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 2443 2444 if (plt_entsize == 0) 2445 { 2446 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the size of the plt 2447 // entries based on the number of entries and the size of the plt section with the 2448 // assumption that the size of the 0th entry is at least as big as the size of the normal 2449 // entries and it isn't much bigger then that. 2450 if (plt_hdr->sh_addralign) 2451 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign; 2452 else 2453 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2454 } 2455 2456 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2457 2458 return std::make_pair(plt_entsize, plt_offset); 2459 } 2460 2461 static unsigned 2462 ParsePLTRelocations(Symtab *symbol_table, 2463 user_id_t start_id, 2464 unsigned rel_type, 2465 const ELFHeader *hdr, 2466 const ELFSectionHeader *rel_hdr, 2467 const ELFSectionHeader *plt_hdr, 2468 const ELFSectionHeader *sym_hdr, 2469 const lldb::SectionSP &plt_section_sp, 2470 DataExtractor &rel_data, 2471 DataExtractor &symtab_data, 2472 DataExtractor &strtab_data) 2473 { 2474 ELFRelocation rel(rel_type); 2475 ELFSymbol symbol; 2476 lldb::offset_t offset = 0; 2477 2478 uint64_t plt_offset, plt_entsize; 2479 std::tie(plt_entsize, plt_offset) = GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2480 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2481 2482 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2483 reloc_info_fn reloc_type; 2484 reloc_info_fn reloc_symbol; 2485 2486 if (hdr->Is32Bit()) 2487 { 2488 reloc_type = ELFRelocation::RelocType32; 2489 reloc_symbol = ELFRelocation::RelocSymbol32; 2490 } 2491 else 2492 { 2493 reloc_type = ELFRelocation::RelocType64; 2494 reloc_symbol = ELFRelocation::RelocSymbol64; 2495 } 2496 2497 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2498 unsigned i; 2499 for (i = 0; i < num_relocations; ++i) 2500 { 2501 if (rel.Parse(rel_data, &offset) == false) 2502 break; 2503 2504 if (reloc_type(rel) != slot_type) 2505 continue; 2506 2507 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2508 if (!symbol.Parse(symtab_data, &symbol_offset)) 2509 break; 2510 2511 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2512 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2513 uint64_t plt_index = plt_offset + i * plt_entsize; 2514 2515 Symbol jump_symbol( 2516 i + start_id, // Symbol table index 2517 symbol_name, // symbol name. 2518 is_mangled, // is the symbol name mangled? 2519 eSymbolTypeTrampoline, // Type of this symbol 2520 false, // Is this globally visible? 2521 false, // Is this symbol debug info? 2522 true, // Is this symbol a trampoline? 2523 true, // Is this symbol artificial? 2524 plt_section_sp, // Section in which this symbol is defined or null. 2525 plt_index, // Offset in section or symbol value. 2526 plt_entsize, // Size in bytes of this symbol. 2527 true, // Size is valid 2528 false, // Contains linker annotations? 2529 0); // Symbol flags. 2530 2531 symbol_table->AddSymbol(jump_symbol); 2532 } 2533 2534 return i; 2535 } 2536 2537 unsigned 2538 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2539 user_id_t start_id, 2540 const ELFSectionHeaderInfo *rel_hdr, 2541 user_id_t rel_id) 2542 { 2543 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2544 2545 // The link field points to the associated symbol table. The info field 2546 // points to the section holding the plt. 2547 user_id_t symtab_id = rel_hdr->sh_link; 2548 user_id_t plt_id = rel_hdr->sh_info; 2549 2550 // If the link field doesn't point to the appropriate symbol name table then 2551 // try to find it by name as some compiler don't fill in the link fields. 2552 if (!symtab_id) 2553 symtab_id = GetSectionIndexByName(".dynsym"); 2554 if (!plt_id) 2555 plt_id = GetSectionIndexByName(".plt"); 2556 2557 if (!symtab_id || !plt_id) 2558 return 0; 2559 2560 // Section ID's are ones based; 2561 symtab_id++; 2562 plt_id++; 2563 2564 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2565 if (!plt_hdr) 2566 return 0; 2567 2568 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2569 if (!sym_hdr) 2570 return 0; 2571 2572 SectionList *section_list = m_sections_ap.get(); 2573 if (!section_list) 2574 return 0; 2575 2576 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2577 if (!rel_section) 2578 return 0; 2579 2580 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2581 if (!plt_section_sp) 2582 return 0; 2583 2584 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2585 if (!symtab) 2586 return 0; 2587 2588 // sh_link points to associated string table. 2589 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2590 if (!strtab) 2591 return 0; 2592 2593 DataExtractor rel_data; 2594 if (!ReadSectionData(rel_section, rel_data)) 2595 return 0; 2596 2597 DataExtractor symtab_data; 2598 if (!ReadSectionData(symtab, symtab_data)) 2599 return 0; 2600 2601 DataExtractor strtab_data; 2602 if (!ReadSectionData(strtab, strtab_data)) 2603 return 0; 2604 2605 unsigned rel_type = PLTRelocationType(); 2606 if (!rel_type) 2607 return 0; 2608 2609 return ParsePLTRelocations (symbol_table, 2610 start_id, 2611 rel_type, 2612 &m_header, 2613 rel_hdr, 2614 plt_hdr, 2615 sym_hdr, 2616 plt_section_sp, 2617 rel_data, 2618 symtab_data, 2619 strtab_data); 2620 } 2621 2622 unsigned 2623 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2624 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2625 DataExtractor &rel_data, DataExtractor &symtab_data, 2626 DataExtractor &debug_data, Section* rel_section) 2627 { 2628 ELFRelocation rel(rel_hdr->sh_type); 2629 lldb::addr_t offset = 0; 2630 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2631 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2632 reloc_info_fn reloc_type; 2633 reloc_info_fn reloc_symbol; 2634 2635 if (hdr->Is32Bit()) 2636 { 2637 reloc_type = ELFRelocation::RelocType32; 2638 reloc_symbol = ELFRelocation::RelocSymbol32; 2639 } 2640 else 2641 { 2642 reloc_type = ELFRelocation::RelocType64; 2643 reloc_symbol = ELFRelocation::RelocSymbol64; 2644 } 2645 2646 for (unsigned i = 0; i < num_relocations; ++i) 2647 { 2648 if (rel.Parse(rel_data, &offset) == false) 2649 break; 2650 2651 Symbol* symbol = NULL; 2652 2653 if (hdr->Is32Bit()) 2654 { 2655 switch (reloc_type(rel)) { 2656 case R_386_32: 2657 case R_386_PC32: 2658 default: 2659 assert(false && "unexpected relocation type"); 2660 } 2661 } else { 2662 switch (reloc_type(rel)) { 2663 case R_X86_64_64: 2664 { 2665 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2666 if (symbol) 2667 { 2668 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2669 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2670 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2671 *dst = value + ELFRelocation::RelocAddend64(rel); 2672 } 2673 break; 2674 } 2675 case R_X86_64_32: 2676 case R_X86_64_32S: 2677 { 2678 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2679 if (symbol) 2680 { 2681 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2682 value += ELFRelocation::RelocAddend32(rel); 2683 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2684 (reloc_type(rel) == R_X86_64_32S && 2685 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2686 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2687 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2688 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2689 *dst = truncated_addr; 2690 } 2691 break; 2692 } 2693 case R_X86_64_PC32: 2694 default: 2695 assert(false && "unexpected relocation type"); 2696 } 2697 } 2698 } 2699 2700 return 0; 2701 } 2702 2703 unsigned 2704 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2705 { 2706 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2707 2708 // Parse in the section list if needed. 2709 SectionList *section_list = GetSectionList(); 2710 if (!section_list) 2711 return 0; 2712 2713 // Section ID's are ones based. 2714 user_id_t symtab_id = rel_hdr->sh_link + 1; 2715 user_id_t debug_id = rel_hdr->sh_info + 1; 2716 2717 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2718 if (!symtab_hdr) 2719 return 0; 2720 2721 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2722 if (!debug_hdr) 2723 return 0; 2724 2725 Section *rel = section_list->FindSectionByID(rel_id).get(); 2726 if (!rel) 2727 return 0; 2728 2729 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2730 if (!symtab) 2731 return 0; 2732 2733 Section *debug = section_list->FindSectionByID(debug_id).get(); 2734 if (!debug) 2735 return 0; 2736 2737 DataExtractor rel_data; 2738 DataExtractor symtab_data; 2739 DataExtractor debug_data; 2740 2741 if (ReadSectionData(rel, rel_data) && 2742 ReadSectionData(symtab, symtab_data) && 2743 ReadSectionData(debug, debug_data)) 2744 { 2745 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2746 rel_data, symtab_data, debug_data, debug); 2747 } 2748 2749 return 0; 2750 } 2751 2752 Symtab * 2753 ObjectFileELF::GetSymtab() 2754 { 2755 ModuleSP module_sp(GetModule()); 2756 if (!module_sp) 2757 return NULL; 2758 2759 // We always want to use the main object file so we (hopefully) only have one cached copy 2760 // of our symtab, dynamic sections, etc. 2761 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2762 if (module_obj_file && module_obj_file != this) 2763 return module_obj_file->GetSymtab(); 2764 2765 if (m_symtab_ap.get() == NULL) 2766 { 2767 SectionList *section_list = module_sp->GetSectionList(); 2768 if (!section_list) 2769 return NULL; 2770 2771 uint64_t symbol_id = 0; 2772 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2773 2774 // Sharable objects and dynamic executables usually have 2 distinct symbol 2775 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2776 // version of the symtab that only contains global symbols. The information found 2777 // in the dynsym is therefore also found in the symtab, while the reverse is not 2778 // necessarily true. 2779 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2780 if (!symtab) 2781 { 2782 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2783 // then use the dynsym section which should always be there. 2784 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2785 } 2786 if (symtab) 2787 { 2788 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile())); 2789 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2790 } 2791 2792 // DT_JMPREL 2793 // If present, this entry's d_ptr member holds the address of relocation 2794 // entries associated solely with the procedure linkage table. Separating 2795 // these relocation entries lets the dynamic linker ignore them during 2796 // process initialization, if lazy binding is enabled. If this entry is 2797 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2798 // also be present. 2799 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2800 if (symbol) 2801 { 2802 // Synthesize trampoline symbols to help navigate the PLT. 2803 addr_t addr = symbol->d_ptr; 2804 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2805 if (reloc_section) 2806 { 2807 user_id_t reloc_id = reloc_section->GetID(); 2808 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2809 assert(reloc_header); 2810 2811 if (m_symtab_ap == nullptr) 2812 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile())); 2813 2814 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2815 } 2816 } 2817 2818 // If we still don't have any symtab then create an empty instance to avoid do the section 2819 // lookup next time. 2820 if (m_symtab_ap == nullptr) 2821 m_symtab_ap.reset(new Symtab(this)); 2822 2823 m_symtab_ap->CalculateSymbolSizes(); 2824 } 2825 2826 for (SectionHeaderCollIter I = m_section_headers.begin(); 2827 I != m_section_headers.end(); ++I) 2828 { 2829 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2830 { 2831 if (CalculateType() == eTypeObjectFile) 2832 { 2833 const char *section_name = I->section_name.AsCString(""); 2834 if (strstr(section_name, ".rela.debug") || 2835 strstr(section_name, ".rel.debug")) 2836 { 2837 const ELFSectionHeader &reloc_header = *I; 2838 user_id_t reloc_id = SectionIndex(I); 2839 RelocateDebugSections(&reloc_header, reloc_id); 2840 } 2841 } 2842 } 2843 } 2844 return m_symtab_ap.get(); 2845 } 2846 2847 Symbol * 2848 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2849 { 2850 if (!m_symtab_ap.get()) 2851 return nullptr; // GetSymtab() should be called first. 2852 2853 const SectionList *section_list = GetSectionList(); 2854 if (!section_list) 2855 return nullptr; 2856 2857 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2858 { 2859 AddressRange range; 2860 if (eh_frame->GetAddressRange (so_addr, range)) 2861 { 2862 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2863 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2864 if (symbol) 2865 return symbol; 2866 2867 // Note that a (stripped) symbol won't be found by GetSymtab()... 2868 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2869 if (eh_sym_section_sp.get()) 2870 { 2871 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2872 addr_t offset = file_addr - section_base; 2873 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2874 2875 Symbol eh_symbol( 2876 symbol_id, // Symbol table index. 2877 "???", // Symbol name. 2878 false, // Is the symbol name mangled? 2879 eSymbolTypeCode, // Type of this symbol. 2880 true, // Is this globally visible? 2881 false, // Is this symbol debug info? 2882 false, // Is this symbol a trampoline? 2883 true, // Is this symbol artificial? 2884 eh_sym_section_sp, // Section in which this symbol is defined or null. 2885 offset, // Offset in section or symbol value. 2886 range.GetByteSize(), // Size in bytes of this symbol. 2887 true, // Size is valid. 2888 false, // Contains linker annotations? 2889 0); // Symbol flags. 2890 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2891 return m_symtab_ap->SymbolAtIndex(symbol_id); 2892 } 2893 } 2894 } 2895 return nullptr; 2896 } 2897 2898 2899 bool 2900 ObjectFileELF::IsStripped () 2901 { 2902 // TODO: determine this for ELF 2903 return false; 2904 } 2905 2906 //===----------------------------------------------------------------------===// 2907 // Dump 2908 // 2909 // Dump the specifics of the runtime file container (such as any headers 2910 // segments, sections, etc). 2911 //---------------------------------------------------------------------- 2912 void 2913 ObjectFileELF::Dump(Stream *s) 2914 { 2915 DumpELFHeader(s, m_header); 2916 s->EOL(); 2917 DumpELFProgramHeaders(s); 2918 s->EOL(); 2919 DumpELFSectionHeaders(s); 2920 s->EOL(); 2921 SectionList *section_list = GetSectionList(); 2922 if (section_list) 2923 section_list->Dump(s, NULL, true, UINT32_MAX); 2924 Symtab *symtab = GetSymtab(); 2925 if (symtab) 2926 symtab->Dump(s, NULL, eSortOrderNone); 2927 s->EOL(); 2928 DumpDependentModules(s); 2929 s->EOL(); 2930 } 2931 2932 //---------------------------------------------------------------------- 2933 // DumpELFHeader 2934 // 2935 // Dump the ELF header to the specified output stream 2936 //---------------------------------------------------------------------- 2937 void 2938 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2939 { 2940 s->PutCString("ELF Header\n"); 2941 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2942 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2943 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2944 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2945 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2946 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2947 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2948 2949 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2950 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2951 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2952 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2953 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2954 2955 s->Printf("e_type = 0x%4.4x ", header.e_type); 2956 DumpELFHeader_e_type(s, header.e_type); 2957 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2958 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2959 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2960 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2961 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2962 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2963 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2964 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2965 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2966 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2967 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2968 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2969 } 2970 2971 //---------------------------------------------------------------------- 2972 // DumpELFHeader_e_type 2973 // 2974 // Dump an token value for the ELF header member e_type 2975 //---------------------------------------------------------------------- 2976 void 2977 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2978 { 2979 switch (e_type) 2980 { 2981 case ET_NONE: *s << "ET_NONE"; break; 2982 case ET_REL: *s << "ET_REL"; break; 2983 case ET_EXEC: *s << "ET_EXEC"; break; 2984 case ET_DYN: *s << "ET_DYN"; break; 2985 case ET_CORE: *s << "ET_CORE"; break; 2986 default: 2987 break; 2988 } 2989 } 2990 2991 //---------------------------------------------------------------------- 2992 // DumpELFHeader_e_ident_EI_DATA 2993 // 2994 // Dump an token value for the ELF header member e_ident[EI_DATA] 2995 //---------------------------------------------------------------------- 2996 void 2997 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2998 { 2999 switch (ei_data) 3000 { 3001 case ELFDATANONE: *s << "ELFDATANONE"; break; 3002 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 3003 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 3004 default: 3005 break; 3006 } 3007 } 3008 3009 3010 //---------------------------------------------------------------------- 3011 // DumpELFProgramHeader 3012 // 3013 // Dump a single ELF program header to the specified output stream 3014 //---------------------------------------------------------------------- 3015 void 3016 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 3017 { 3018 DumpELFProgramHeader_p_type(s, ph.p_type); 3019 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 3020 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 3021 3022 DumpELFProgramHeader_p_flags(s, ph.p_flags); 3023 s->Printf(") %8.8" PRIx64, ph.p_align); 3024 } 3025 3026 //---------------------------------------------------------------------- 3027 // DumpELFProgramHeader_p_type 3028 // 3029 // Dump an token value for the ELF program header member p_type which 3030 // describes the type of the program header 3031 // ---------------------------------------------------------------------- 3032 void 3033 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 3034 { 3035 const int kStrWidth = 15; 3036 switch (p_type) 3037 { 3038 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 3039 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 3040 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 3041 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 3042 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 3043 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 3044 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 3045 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 3046 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 3047 default: 3048 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 3049 break; 3050 } 3051 } 3052 3053 3054 //---------------------------------------------------------------------- 3055 // DumpELFProgramHeader_p_flags 3056 // 3057 // Dump an token value for the ELF program header member p_flags 3058 //---------------------------------------------------------------------- 3059 void 3060 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 3061 { 3062 *s << ((p_flags & PF_X) ? "PF_X" : " ") 3063 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 3064 << ((p_flags & PF_W) ? "PF_W" : " ") 3065 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 3066 << ((p_flags & PF_R) ? "PF_R" : " "); 3067 } 3068 3069 //---------------------------------------------------------------------- 3070 // DumpELFProgramHeaders 3071 // 3072 // Dump all of the ELF program header to the specified output stream 3073 //---------------------------------------------------------------------- 3074 void 3075 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 3076 { 3077 if (!ParseProgramHeaders()) 3078 return; 3079 3080 s->PutCString("Program Headers\n"); 3081 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 3082 "p_filesz p_memsz p_flags p_align\n"); 3083 s->PutCString("==== --------------- -------- -------- -------- " 3084 "-------- -------- ------------------------- --------\n"); 3085 3086 uint32_t idx = 0; 3087 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 3088 I != m_program_headers.end(); ++I, ++idx) 3089 { 3090 s->Printf("[%2u] ", idx); 3091 ObjectFileELF::DumpELFProgramHeader(s, *I); 3092 s->EOL(); 3093 } 3094 } 3095 3096 //---------------------------------------------------------------------- 3097 // DumpELFSectionHeader 3098 // 3099 // Dump a single ELF section header to the specified output stream 3100 //---------------------------------------------------------------------- 3101 void 3102 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 3103 { 3104 s->Printf("%8.8x ", sh.sh_name); 3105 DumpELFSectionHeader_sh_type(s, sh.sh_type); 3106 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 3107 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 3108 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 3109 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 3110 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 3111 } 3112 3113 //---------------------------------------------------------------------- 3114 // DumpELFSectionHeader_sh_type 3115 // 3116 // Dump an token value for the ELF section header member sh_type which 3117 // describes the type of the section 3118 //---------------------------------------------------------------------- 3119 void 3120 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 3121 { 3122 const int kStrWidth = 12; 3123 switch (sh_type) 3124 { 3125 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 3126 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 3127 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 3128 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 3129 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 3130 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 3131 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 3132 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 3133 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 3134 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 3135 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 3136 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 3137 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 3138 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 3139 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 3140 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 3141 default: 3142 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 3143 break; 3144 } 3145 } 3146 3147 //---------------------------------------------------------------------- 3148 // DumpELFSectionHeader_sh_flags 3149 // 3150 // Dump an token value for the ELF section header member sh_flags 3151 //---------------------------------------------------------------------- 3152 void 3153 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 3154 { 3155 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3156 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3157 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3158 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3159 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3160 } 3161 3162 //---------------------------------------------------------------------- 3163 // DumpELFSectionHeaders 3164 // 3165 // Dump all of the ELF section header to the specified output stream 3166 //---------------------------------------------------------------------- 3167 void 3168 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 3169 { 3170 if (!ParseSectionHeaders()) 3171 return; 3172 3173 s->PutCString("Section Headers\n"); 3174 s->PutCString("IDX name type flags " 3175 "addr offset size link info addralgn " 3176 "entsize Name\n"); 3177 s->PutCString("==== -------- ------------ -------------------------------- " 3178 "-------- -------- -------- -------- -------- -------- " 3179 "-------- ====================\n"); 3180 3181 uint32_t idx = 0; 3182 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3183 I != m_section_headers.end(); ++I, ++idx) 3184 { 3185 s->Printf("[%2u] ", idx); 3186 ObjectFileELF::DumpELFSectionHeader(s, *I); 3187 const char* section_name = I->section_name.AsCString(""); 3188 if (section_name) 3189 *s << ' ' << section_name << "\n"; 3190 } 3191 } 3192 3193 void 3194 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 3195 { 3196 size_t num_modules = ParseDependentModules(); 3197 3198 if (num_modules > 0) 3199 { 3200 s->PutCString("Dependent Modules:\n"); 3201 for (unsigned i = 0; i < num_modules; ++i) 3202 { 3203 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 3204 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3205 } 3206 } 3207 } 3208 3209 bool 3210 ObjectFileELF::GetArchitecture (ArchSpec &arch) 3211 { 3212 if (!ParseHeader()) 3213 return false; 3214 3215 if (m_section_headers.empty()) 3216 { 3217 // Allow elf notes to be parsed which may affect the detected architecture. 3218 ParseSectionHeaders(); 3219 } 3220 3221 if (CalculateType() == eTypeCoreFile && m_arch_spec.TripleOSIsUnspecifiedUnknown()) 3222 { 3223 // Core files don't have section headers yet they have PT_NOTE program headers 3224 // that might shed more light on the architecture 3225 if (ParseProgramHeaders()) 3226 { 3227 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) 3228 { 3229 const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i); 3230 if (header && header->p_type == PT_NOTE && header->p_offset != 0 && header->p_filesz > 0) 3231 { 3232 DataExtractor data; 3233 if (data.SetData (m_data, header->p_offset, header->p_filesz) == header->p_filesz) 3234 { 3235 lldb_private::UUID uuid; 3236 RefineModuleDetailsFromNote (data, m_arch_spec, uuid); 3237 } 3238 } 3239 } 3240 } 3241 } 3242 arch = m_arch_spec; 3243 return true; 3244 } 3245 3246 ObjectFile::Type 3247 ObjectFileELF::CalculateType() 3248 { 3249 switch (m_header.e_type) 3250 { 3251 case llvm::ELF::ET_NONE: 3252 // 0 - No file type 3253 return eTypeUnknown; 3254 3255 case llvm::ELF::ET_REL: 3256 // 1 - Relocatable file 3257 return eTypeObjectFile; 3258 3259 case llvm::ELF::ET_EXEC: 3260 // 2 - Executable file 3261 return eTypeExecutable; 3262 3263 case llvm::ELF::ET_DYN: 3264 // 3 - Shared object file 3265 return eTypeSharedLibrary; 3266 3267 case ET_CORE: 3268 // 4 - Core file 3269 return eTypeCoreFile; 3270 3271 default: 3272 break; 3273 } 3274 return eTypeUnknown; 3275 } 3276 3277 ObjectFile::Strata 3278 ObjectFileELF::CalculateStrata() 3279 { 3280 switch (m_header.e_type) 3281 { 3282 case llvm::ELF::ET_NONE: 3283 // 0 - No file type 3284 return eStrataUnknown; 3285 3286 case llvm::ELF::ET_REL: 3287 // 1 - Relocatable file 3288 return eStrataUnknown; 3289 3290 case llvm::ELF::ET_EXEC: 3291 // 2 - Executable file 3292 // TODO: is there any way to detect that an executable is a kernel 3293 // related executable by inspecting the program headers, section 3294 // headers, symbols, or any other flag bits??? 3295 return eStrataUser; 3296 3297 case llvm::ELF::ET_DYN: 3298 // 3 - Shared object file 3299 // TODO: is there any way to detect that an shared library is a kernel 3300 // related executable by inspecting the program headers, section 3301 // headers, symbols, or any other flag bits??? 3302 return eStrataUnknown; 3303 3304 case ET_CORE: 3305 // 4 - Core file 3306 // TODO: is there any way to detect that an core file is a kernel 3307 // related executable by inspecting the program headers, section 3308 // headers, symbols, or any other flag bits??? 3309 return eStrataUnknown; 3310 3311 default: 3312 break; 3313 } 3314 return eStrataUnknown; 3315 } 3316 3317