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::alignTo (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_32: 334 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el : ArchSpec::eMIPSSubType_mips32; 335 case llvm::ELF::EF_MIPS_ARCH_32R2: 336 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el : ArchSpec::eMIPSSubType_mips32r2; 337 case llvm::ELF::EF_MIPS_ARCH_32R6: 338 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el : ArchSpec::eMIPSSubType_mips32r6; 339 case llvm::ELF::EF_MIPS_ARCH_3: 340 case llvm::ELF::EF_MIPS_ARCH_4: 341 case llvm::ELF::EF_MIPS_ARCH_5: 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 using namespace std::placeholders; 733 const SetDataFunction set_data = std::bind(&ObjectFileELF::SetData, std::cref(data), _1, _2, _3); 734 GetSectionHeaderInfo(section_headers, set_data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc, spec.GetArchitecture ()); 735 736 737 llvm::Triple &spec_triple = spec.GetArchitecture ().GetTriple (); 738 739 if (log) 740 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 ()); 741 742 if (!uuid.IsValid()) 743 { 744 uint32_t core_notes_crc = 0; 745 746 if (!gnu_debuglink_crc) 747 { 748 lldb_private::Timer scoped_timer (__PRETTY_FUNCTION__, 749 "Calculating module crc32 %s with size %" PRIu64 " KiB", 750 file.GetLastPathComponent().AsCString(), 751 (file.GetByteSize()-file_offset)/1024); 752 753 // For core files - which usually don't happen to have a gnu_debuglink, 754 // and are pretty bulky - calculating whole contents crc32 would be too much of luxury. 755 // Thus we will need to fallback to something simpler. 756 if (header.e_type == llvm::ELF::ET_CORE) 757 { 758 size_t program_headers_end = header.e_phoff + header.e_phnum * header.e_phentsize; 759 if (program_headers_end > data_sp->GetByteSize()) 760 { 761 data_sp = file.MemoryMapFileContentsIfLocal(file_offset, program_headers_end); 762 data.SetData(data_sp); 763 } 764 ProgramHeaderColl program_headers; 765 GetProgramHeaderInfo(program_headers, set_data, header); 766 767 size_t segment_data_end = 0; 768 for (ProgramHeaderCollConstIter I = program_headers.begin(); 769 I != program_headers.end(); ++I) 770 { 771 segment_data_end = std::max<unsigned long long> (I->p_offset + I->p_filesz, segment_data_end); 772 } 773 774 if (segment_data_end > data_sp->GetByteSize()) 775 { 776 data_sp = file.MemoryMapFileContentsIfLocal(file_offset, segment_data_end); 777 data.SetData(data_sp); 778 } 779 780 core_notes_crc = CalculateELFNotesSegmentsCRC32 (program_headers, data); 781 } 782 else 783 { 784 // Need to map entire file into memory to calculate the crc. 785 data_sp = file.MemoryMapFileContentsIfLocal (file_offset, SIZE_MAX); 786 data.SetData(data_sp); 787 gnu_debuglink_crc = calc_gnu_debuglink_crc32 (data.GetDataStart(), data.GetByteSize()); 788 } 789 } 790 if (gnu_debuglink_crc) 791 { 792 // Use 4 bytes of crc from the .gnu_debuglink section. 793 uint32_t uuidt[4] = { gnu_debuglink_crc, 0, 0, 0 }; 794 uuid.SetBytes (uuidt, sizeof(uuidt)); 795 } 796 else if (core_notes_crc) 797 { 798 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it look different form 799 // .gnu_debuglink crc followed by 4 bytes of note segments crc. 800 uint32_t uuidt[4] = { g_core_uuid_magic, core_notes_crc, 0, 0 }; 801 uuid.SetBytes (uuidt, sizeof(uuidt)); 802 } 803 } 804 805 specs.Append(spec); 806 } 807 } 808 } 809 } 810 811 return specs.GetSize() - initial_count; 812 } 813 814 //------------------------------------------------------------------ 815 // PluginInterface protocol 816 //------------------------------------------------------------------ 817 lldb_private::ConstString 818 ObjectFileELF::GetPluginName() 819 { 820 return GetPluginNameStatic(); 821 } 822 823 uint32_t 824 ObjectFileELF::GetPluginVersion() 825 { 826 return m_plugin_version; 827 } 828 //------------------------------------------------------------------ 829 // ObjectFile protocol 830 //------------------------------------------------------------------ 831 832 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 833 DataBufferSP& data_sp, 834 lldb::offset_t data_offset, 835 const FileSpec* file, 836 lldb::offset_t file_offset, 837 lldb::offset_t length) : 838 ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset), 839 m_header(), 840 m_uuid(), 841 m_gnu_debuglink_file(), 842 m_gnu_debuglink_crc(0), 843 m_program_headers(), 844 m_section_headers(), 845 m_dynamic_symbols(), 846 m_filespec_ap(), 847 m_entry_point_address(), 848 m_arch_spec() 849 { 850 if (file) 851 m_file = *file; 852 ::memset(&m_header, 0, sizeof(m_header)); 853 } 854 855 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp, 856 DataBufferSP& header_data_sp, 857 const lldb::ProcessSP &process_sp, 858 addr_t header_addr) : 859 ObjectFile(module_sp, process_sp, header_addr, header_data_sp), 860 m_header(), 861 m_uuid(), 862 m_gnu_debuglink_file(), 863 m_gnu_debuglink_crc(0), 864 m_program_headers(), 865 m_section_headers(), 866 m_dynamic_symbols(), 867 m_filespec_ap(), 868 m_entry_point_address(), 869 m_arch_spec() 870 { 871 ::memset(&m_header, 0, sizeof(m_header)); 872 } 873 874 ObjectFileELF::~ObjectFileELF() 875 { 876 } 877 878 bool 879 ObjectFileELF::IsExecutable() const 880 { 881 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0); 882 } 883 884 bool 885 ObjectFileELF::SetLoadAddress (Target &target, 886 lldb::addr_t value, 887 bool value_is_offset) 888 { 889 ModuleSP module_sp = GetModule(); 890 if (module_sp) 891 { 892 size_t num_loaded_sections = 0; 893 SectionList *section_list = GetSectionList (); 894 if (section_list) 895 { 896 if (!value_is_offset) 897 { 898 bool found_offset = false; 899 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) 900 { 901 const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i); 902 if (header == nullptr) 903 continue; 904 905 if (header->p_type != PT_LOAD || header->p_offset != 0) 906 continue; 907 908 value = value - header->p_vaddr; 909 found_offset = true; 910 break; 911 } 912 if (!found_offset) 913 return false; 914 } 915 916 const size_t num_sections = section_list->GetSize(); 917 size_t sect_idx = 0; 918 919 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) 920 { 921 // Iterate through the object file sections to find all 922 // of the sections that have SHF_ALLOC in their flag bits. 923 SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx)); 924 // if (section_sp && !section_sp->IsThreadSpecific()) 925 if (section_sp && section_sp->Test(SHF_ALLOC)) 926 { 927 lldb::addr_t load_addr = section_sp->GetFileAddress() + value; 928 929 // On 32-bit systems the load address have to fit into 4 bytes. The rest of 930 // the bytes are the overflow from the addition. 931 if (GetAddressByteSize() == 4) 932 load_addr &= 0xFFFFFFFF; 933 934 if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, load_addr)) 935 ++num_loaded_sections; 936 } 937 } 938 return num_loaded_sections > 0; 939 } 940 } 941 return false; 942 } 943 944 ByteOrder 945 ObjectFileELF::GetByteOrder() const 946 { 947 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB) 948 return eByteOrderBig; 949 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB) 950 return eByteOrderLittle; 951 return eByteOrderInvalid; 952 } 953 954 uint32_t 955 ObjectFileELF::GetAddressByteSize() const 956 { 957 return m_data.GetAddressByteSize(); 958 } 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 const SetDataFunction &set_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 (set_data(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 using namespace std::placeholders; 1305 return GetProgramHeaderInfo(m_program_headers, 1306 std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2, _3), 1307 m_header); 1308 } 1309 1310 lldb_private::Error 1311 ObjectFileELF::RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid) 1312 { 1313 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1314 Error error; 1315 1316 lldb::offset_t offset = 0; 1317 1318 while (true) 1319 { 1320 // Parse the note header. If this fails, bail out. 1321 const lldb::offset_t note_offset = offset; 1322 ELFNote note = ELFNote(); 1323 if (!note.Parse(data, &offset)) 1324 { 1325 // We're done. 1326 return error; 1327 } 1328 1329 if (log) 1330 log->Printf ("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, __FUNCTION__, note.n_name.c_str (), note.n_type); 1331 1332 // Process FreeBSD ELF notes. 1333 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) && 1334 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) && 1335 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) 1336 { 1337 // Pull out the min version info. 1338 uint32_t version_info; 1339 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1340 { 1341 error.SetErrorString ("failed to read FreeBSD ABI note payload"); 1342 return error; 1343 } 1344 1345 // Convert the version info into a major/minor number. 1346 const uint32_t version_major = version_info / 100000; 1347 const uint32_t version_minor = (version_info / 1000) % 100; 1348 1349 char os_name[32]; 1350 snprintf (os_name, sizeof (os_name), "freebsd%" PRIu32 ".%" PRIu32, version_major, version_minor); 1351 1352 // Set the elf OS version to FreeBSD. Also clear the vendor. 1353 arch_spec.GetTriple ().setOSName (os_name); 1354 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1355 1356 if (log) 1357 log->Printf ("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_major, version_minor, static_cast<uint32_t> (version_info % 1000)); 1358 } 1359 // Process GNU ELF notes. 1360 else if (note.n_name == LLDB_NT_OWNER_GNU) 1361 { 1362 switch (note.n_type) 1363 { 1364 case LLDB_NT_GNU_ABI_TAG: 1365 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) 1366 { 1367 // Pull out the min OS version supporting the ABI. 1368 uint32_t version_info[4]; 1369 if (data.GetU32 (&offset, &version_info[0], note.n_descsz / 4) == nullptr) 1370 { 1371 error.SetErrorString ("failed to read GNU ABI note payload"); 1372 return error; 1373 } 1374 1375 // Set the OS per the OS field. 1376 switch (version_info[0]) 1377 { 1378 case LLDB_NT_GNU_ABI_OS_LINUX: 1379 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Linux); 1380 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1381 if (log) 1382 log->Printf ("ObjectFileELF::%s detected Linux, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1383 // 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. 1384 break; 1385 case LLDB_NT_GNU_ABI_OS_HURD: 1386 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::UnknownOS); 1387 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1388 if (log) 1389 log->Printf ("ObjectFileELF::%s detected Hurd (unsupported), min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1390 break; 1391 case LLDB_NT_GNU_ABI_OS_SOLARIS: 1392 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Solaris); 1393 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1394 if (log) 1395 log->Printf ("ObjectFileELF::%s detected Solaris, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1396 break; 1397 default: 1398 if (log) 1399 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]); 1400 break; 1401 } 1402 } 1403 break; 1404 1405 case LLDB_NT_GNU_BUILD_ID_TAG: 1406 // Only bother processing this if we don't already have the uuid set. 1407 if (!uuid.IsValid()) 1408 { 1409 // 16 bytes is UUID|MD5, 20 bytes is SHA1 1410 if ((note.n_descsz == 16 || note.n_descsz == 20)) 1411 { 1412 uint8_t uuidbuf[20]; 1413 if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == nullptr) 1414 { 1415 error.SetErrorString ("failed to read GNU_BUILD_ID note payload"); 1416 return error; 1417 } 1418 1419 // Save the build id as the UUID for the module. 1420 uuid.SetBytes (uuidbuf, note.n_descsz); 1421 } 1422 } 1423 break; 1424 } 1425 } 1426 // Process NetBSD ELF notes. 1427 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) && 1428 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) && 1429 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) 1430 { 1431 // Pull out the min version info. 1432 uint32_t version_info; 1433 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1434 { 1435 error.SetErrorString ("failed to read NetBSD ABI note payload"); 1436 return error; 1437 } 1438 1439 // Set the elf OS version to NetBSD. Also clear the vendor. 1440 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::NetBSD); 1441 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1442 1443 if (log) 1444 log->Printf ("ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32, __FUNCTION__, version_info); 1445 } 1446 // Process CSR kalimba notes 1447 else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) && 1448 (note.n_name == LLDB_NT_OWNER_CSR)) 1449 { 1450 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS); 1451 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR); 1452 1453 // TODO At some point the description string could be processed. 1454 // It could provide a steer towards the kalimba variant which 1455 // this ELF targets. 1456 if(note.n_descsz) 1457 { 1458 const char *cstr = data.GetCStr(&offset, llvm::alignTo (note.n_descsz, 4)); 1459 (void)cstr; 1460 } 1461 } 1462 else if (note.n_name == LLDB_NT_OWNER_ANDROID) 1463 { 1464 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1465 arch_spec.GetTriple().setEnvironment(llvm::Triple::EnvironmentType::Android); 1466 } 1467 else if (note.n_name == LLDB_NT_OWNER_LINUX) 1468 { 1469 // This is sometimes found in core files and usually contains extended register info 1470 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1471 } 1472 else if (note.n_name == LLDB_NT_OWNER_CORE) 1473 { 1474 // Parse the NT_FILE to look for stuff in paths to shared libraries 1475 // As the contents look like: 1476 // count = 0x000000000000000a (10) 1477 // page_size = 0x0000000000001000 (4096) 1478 // Index start end file_ofs path 1479 // ===== ------------------ ------------------ ------------------ ------------------------------------- 1480 // [ 0] 0x0000000000400000 0x0000000000401000 0x0000000000000000 /tmp/a.out 1481 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out 1482 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out 1483 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000 /lib/x86_64-linux-gnu/libc-2.19.so 1484 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-gnu/libc-2.19.so 1485 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so 1486 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64-linux-gnu/libc-2.19.so 1487 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so 1488 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64-linux-gnu/ld-2.19.so 1489 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so 1490 if (note.n_type == NT_FILE) 1491 { 1492 uint64_t count = data.GetU64(&offset); 1493 offset += 8 + 3*8*count; // Skip page size and all start/end/file_ofs 1494 for (size_t i=0; i<count; ++i) 1495 { 1496 llvm::StringRef path(data.GetCStr(&offset)); 1497 if (path.startswith("/lib/x86_64-linux-gnu")) 1498 { 1499 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1500 break; 1501 } 1502 } 1503 } 1504 } 1505 1506 // Calculate the offset of the next note just in case "offset" has been used 1507 // to poke at the contents of the note data 1508 offset = note_offset + note.GetByteSize(); 1509 } 1510 1511 return error; 1512 } 1513 1514 1515 //---------------------------------------------------------------------- 1516 // GetSectionHeaderInfo 1517 //---------------------------------------------------------------------- 1518 size_t 1519 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1520 const SetDataFunction &set_data, 1521 const elf::ELFHeader &header, 1522 lldb_private::UUID &uuid, 1523 std::string &gnu_debuglink_file, 1524 uint32_t &gnu_debuglink_crc, 1525 ArchSpec &arch_spec) 1526 { 1527 // Don't reparse the section headers if we already did that. 1528 if (!section_headers.empty()) 1529 return section_headers.size(); 1530 1531 // Only initialize the arch_spec to okay defaults if they're not already set. 1532 // We'll refine this with note data as we parse the notes. 1533 if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS) 1534 { 1535 llvm::Triple::OSType ostype; 1536 llvm::Triple::OSType spec_ostype; 1537 const uint32_t sub_type = subTypeFromElfHeader(header); 1538 arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]); 1539 // 1540 // Validate if it is ok to remove GetOsFromOSABI 1541 GetOsFromOSABI (header.e_ident[EI_OSABI], ostype); 1542 spec_ostype = arch_spec.GetTriple ().getOS (); 1543 assert(spec_ostype == ostype); 1544 } 1545 1546 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1547 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1548 { 1549 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) 1550 { 1551 case llvm::ELF::EF_MIPS_MICROMIPS: 1552 arch_spec.SetFlags (ArchSpec::eMIPSAse_micromips); 1553 break; 1554 case llvm::ELF::EF_MIPS_ARCH_ASE_M16: 1555 arch_spec.SetFlags (ArchSpec::eMIPSAse_mips16); 1556 break; 1557 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX: 1558 arch_spec.SetFlags (ArchSpec::eMIPSAse_mdmx); 1559 break; 1560 default: 1561 break; 1562 } 1563 } 1564 1565 if (arch_spec.GetMachine() == llvm::Triple::arm || 1566 arch_spec.GetMachine() == llvm::Triple::thumb) 1567 { 1568 if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT) 1569 arch_spec.SetFlags (ArchSpec::eARM_abi_soft_float); 1570 else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT) 1571 arch_spec.SetFlags (ArchSpec::eARM_abi_hard_float); 1572 } 1573 1574 // If there are no section headers we are done. 1575 if (header.e_shnum == 0) 1576 return 0; 1577 1578 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1579 1580 section_headers.resize(header.e_shnum); 1581 if (section_headers.size() != header.e_shnum) 1582 return 0; 1583 1584 const size_t sh_size = header.e_shnum * header.e_shentsize; 1585 const elf_off sh_offset = header.e_shoff; 1586 DataExtractor sh_data; 1587 if (set_data (sh_data, sh_offset, sh_size) != sh_size) 1588 return 0; 1589 1590 uint32_t idx; 1591 lldb::offset_t offset; 1592 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1593 { 1594 if (section_headers[idx].Parse(sh_data, &offset) == false) 1595 break; 1596 } 1597 if (idx < section_headers.size()) 1598 section_headers.resize(idx); 1599 1600 const unsigned strtab_idx = header.e_shstrndx; 1601 if (strtab_idx && strtab_idx < section_headers.size()) 1602 { 1603 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1604 const size_t byte_size = sheader.sh_size; 1605 const Elf64_Off offset = sheader.sh_offset; 1606 lldb_private::DataExtractor shstr_data; 1607 1608 if (set_data (shstr_data, offset, byte_size) == byte_size) 1609 { 1610 for (SectionHeaderCollIter I = section_headers.begin(); 1611 I != section_headers.end(); ++I) 1612 { 1613 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1614 const ELFSectionHeaderInfo &sheader = *I; 1615 const uint64_t section_size = sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1616 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1617 1618 I->section_name = name; 1619 1620 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1621 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1622 { 1623 uint32_t arch_flags = arch_spec.GetFlags (); 1624 DataExtractor data; 1625 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) 1626 { 1627 1628 if (section_size && (set_data (data, sheader.sh_offset, section_size) == section_size)) 1629 { 1630 lldb::offset_t ase_offset = 12; // MIPS ABI Flags Version: 0 1631 arch_flags |= data.GetU32 (&ase_offset); 1632 } 1633 } 1634 // Settings appropriate ArchSpec ABI Flags 1635 if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1636 { 1637 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1638 } 1639 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI_O32) 1640 { 1641 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1642 } 1643 arch_spec.SetFlags (arch_flags); 1644 } 1645 1646 if (name == g_sect_name_gnu_debuglink) 1647 { 1648 DataExtractor data; 1649 if (section_size && (set_data (data, sheader.sh_offset, section_size) == section_size)) 1650 { 1651 lldb::offset_t gnu_debuglink_offset = 0; 1652 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1653 gnu_debuglink_offset = llvm::alignTo (gnu_debuglink_offset, 4); 1654 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1655 } 1656 } 1657 1658 // Process ELF note section entries. 1659 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1660 1661 // The section header ".note.android.ident" is stored as a 1662 // PROGBITS type header but it is actually a note header. 1663 static ConstString g_sect_name_android_ident (".note.android.ident"); 1664 if (!is_note_header && name == g_sect_name_android_ident) 1665 is_note_header = true; 1666 1667 if (is_note_header) 1668 { 1669 // Allow notes to refine module info. 1670 DataExtractor data; 1671 if (section_size && (set_data (data, sheader.sh_offset, section_size) == section_size)) 1672 { 1673 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1674 if (error.Fail ()) 1675 { 1676 if (log) 1677 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1678 } 1679 } 1680 } 1681 } 1682 1683 // Make any unknown triple components to be unspecified unknowns. 1684 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor) 1685 arch_spec.GetTriple().setVendorName (llvm::StringRef()); 1686 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS) 1687 arch_spec.GetTriple().setOSName (llvm::StringRef()); 1688 1689 return section_headers.size(); 1690 } 1691 } 1692 1693 section_headers.clear(); 1694 return 0; 1695 } 1696 1697 size_t 1698 ObjectFileELF::GetProgramHeaderCount() 1699 { 1700 return ParseProgramHeaders(); 1701 } 1702 1703 const elf::ELFProgramHeader * 1704 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1705 { 1706 if (!id || !ParseProgramHeaders()) 1707 return NULL; 1708 1709 if (--id < m_program_headers.size()) 1710 return &m_program_headers[id]; 1711 1712 return NULL; 1713 } 1714 1715 DataExtractor 1716 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1717 { 1718 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1719 if (segment_header == NULL) 1720 return DataExtractor(); 1721 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1722 } 1723 1724 std::string 1725 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const 1726 { 1727 size_t pos = symbol_name.find('@'); 1728 return symbol_name.substr(0, pos).str(); 1729 } 1730 1731 //---------------------------------------------------------------------- 1732 // ParseSectionHeaders 1733 //---------------------------------------------------------------------- 1734 size_t 1735 ObjectFileELF::ParseSectionHeaders() 1736 { 1737 using namespace std::placeholders; 1738 1739 return GetSectionHeaderInfo(m_section_headers, 1740 std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2, _3), 1741 m_header, 1742 m_uuid, 1743 m_gnu_debuglink_file, 1744 m_gnu_debuglink_crc, 1745 m_arch_spec); 1746 } 1747 1748 lldb::offset_t 1749 ObjectFileELF::SetData(const lldb_private::DataExtractor &src, lldb_private::DataExtractor &dst, lldb::offset_t offset, lldb::offset_t length) 1750 { 1751 return dst.SetData(src, offset, length); 1752 } 1753 1754 lldb::offset_t 1755 ObjectFileELF::SetDataWithReadMemoryFallback(lldb_private::DataExtractor &dst, lldb::offset_t offset, lldb::offset_t length) 1756 { 1757 if (offset + length <= m_data.GetByteSize()) 1758 return dst.SetData(m_data, offset, length); 1759 1760 const auto process_sp = m_process_wp.lock(); 1761 if (process_sp != nullptr) 1762 { 1763 addr_t file_size = offset + length; 1764 1765 DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size); 1766 if (!data_sp) 1767 return false; 1768 m_data.SetData(data_sp, 0, file_size); 1769 } 1770 1771 return dst.SetData(m_data, offset, length); 1772 } 1773 1774 const ObjectFileELF::ELFSectionHeaderInfo * 1775 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1776 { 1777 if (!id || !ParseSectionHeaders()) 1778 return NULL; 1779 1780 if (--id < m_section_headers.size()) 1781 return &m_section_headers[id]; 1782 1783 return NULL; 1784 } 1785 1786 lldb::user_id_t 1787 ObjectFileELF::GetSectionIndexByName(const char* name) 1788 { 1789 if (!name || !name[0] || !ParseSectionHeaders()) 1790 return 0; 1791 for (size_t i = 1; i < m_section_headers.size(); ++i) 1792 if (m_section_headers[i].section_name == ConstString(name)) 1793 return i; 1794 return 0; 1795 } 1796 1797 void 1798 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1799 { 1800 if (!m_sections_ap.get() && ParseSectionHeaders()) 1801 { 1802 m_sections_ap.reset(new SectionList()); 1803 1804 for (SectionHeaderCollIter I = m_section_headers.begin(); 1805 I != m_section_headers.end(); ++I) 1806 { 1807 const ELFSectionHeaderInfo &header = *I; 1808 1809 ConstString& name = I->section_name; 1810 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1811 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1812 1813 static ConstString g_sect_name_text (".text"); 1814 static ConstString g_sect_name_data (".data"); 1815 static ConstString g_sect_name_bss (".bss"); 1816 static ConstString g_sect_name_tdata (".tdata"); 1817 static ConstString g_sect_name_tbss (".tbss"); 1818 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1819 static ConstString g_sect_name_dwarf_debug_addr (".debug_addr"); 1820 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1821 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1822 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1823 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1824 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1825 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1826 static ConstString g_sect_name_dwarf_debug_macro (".debug_macro"); 1827 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1828 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1829 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1830 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1831 static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets"); 1832 static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo"); 1833 static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo"); 1834 static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo"); 1835 static ConstString g_sect_name_dwarf_debug_macro_dwo (".debug_macro.dwo"); 1836 static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo"); 1837 static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo"); 1838 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo"); 1839 static ConstString g_sect_name_eh_frame (".eh_frame"); 1840 static ConstString g_sect_name_arm_exidx (".ARM.exidx"); 1841 static ConstString g_sect_name_arm_extab (".ARM.extab"); 1842 static ConstString g_sect_name_go_symtab (".gosymtab"); 1843 1844 SectionType sect_type = eSectionTypeOther; 1845 1846 bool is_thread_specific = false; 1847 1848 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1849 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1850 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1851 else if (name == g_sect_name_tdata) 1852 { 1853 sect_type = eSectionTypeData; 1854 is_thread_specific = true; 1855 } 1856 else if (name == g_sect_name_tbss) 1857 { 1858 sect_type = eSectionTypeZeroFill; 1859 is_thread_specific = true; 1860 } 1861 // .debug_abbrev – Abbreviations used in the .debug_info section 1862 // .debug_aranges – Lookup table for mapping addresses to compilation units 1863 // .debug_frame – Call frame information 1864 // .debug_info – The core DWARF information section 1865 // .debug_line – Line number information 1866 // .debug_loc – Location lists used in DW_AT_location attributes 1867 // .debug_macinfo – Macro information 1868 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1869 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1870 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1871 // .debug_str – String table used in .debug_info 1872 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1873 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1874 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1875 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1876 else if (name == g_sect_name_dwarf_debug_addr) sect_type = eSectionTypeDWARFDebugAddr; 1877 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1878 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1879 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1880 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1881 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1882 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1883 else if (name == g_sect_name_dwarf_debug_macro) sect_type = eSectionTypeDWARFDebugMacro; 1884 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1885 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1886 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1887 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1888 else if (name == g_sect_name_dwarf_debug_str_offsets) sect_type = eSectionTypeDWARFDebugStrOffsets; 1889 else if (name == g_sect_name_dwarf_debug_abbrev_dwo) sect_type = eSectionTypeDWARFDebugAbbrev; 1890 else if (name == g_sect_name_dwarf_debug_info_dwo) sect_type = eSectionTypeDWARFDebugInfo; 1891 else if (name == g_sect_name_dwarf_debug_line_dwo) sect_type = eSectionTypeDWARFDebugLine; 1892 else if (name == g_sect_name_dwarf_debug_macro_dwo) sect_type = eSectionTypeDWARFDebugMacro; 1893 else if (name == g_sect_name_dwarf_debug_loc_dwo) sect_type = eSectionTypeDWARFDebugLoc; 1894 else if (name == g_sect_name_dwarf_debug_str_dwo) sect_type = eSectionTypeDWARFDebugStr; 1895 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets; 1896 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1897 else if (name == g_sect_name_arm_exidx) sect_type = eSectionTypeARMexidx; 1898 else if (name == g_sect_name_arm_extab) sect_type = eSectionTypeARMextab; 1899 else if (name == g_sect_name_go_symtab) sect_type = eSectionTypeGoSymtab; 1900 1901 switch (header.sh_type) 1902 { 1903 case SHT_SYMTAB: 1904 assert (sect_type == eSectionTypeOther); 1905 sect_type = eSectionTypeELFSymbolTable; 1906 break; 1907 case SHT_DYNSYM: 1908 assert (sect_type == eSectionTypeOther); 1909 sect_type = eSectionTypeELFDynamicSymbols; 1910 break; 1911 case SHT_RELA: 1912 case SHT_REL: 1913 assert (sect_type == eSectionTypeOther); 1914 sect_type = eSectionTypeELFRelocationEntries; 1915 break; 1916 case SHT_DYNAMIC: 1917 assert (sect_type == eSectionTypeOther); 1918 sect_type = eSectionTypeELFDynamicLinkInfo; 1919 break; 1920 } 1921 1922 if (eSectionTypeOther == sect_type) 1923 { 1924 // the kalimba toolchain assumes that ELF section names are free-form. It does 1925 // support linkscripts which (can) give rise to various arbitrarily named 1926 // sections being "Code" or "Data". 1927 sect_type = kalimbaSectionType(m_header, header); 1928 } 1929 1930 const uint32_t target_bytes_size = 1931 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type) ? 1932 m_arch_spec.GetDataByteSize() : 1933 eSectionTypeCode == sect_type ? 1934 m_arch_spec.GetCodeByteSize() : 1; 1935 1936 elf::elf_xword log2align = (header.sh_addralign==0) 1937 ? 0 1938 : llvm::Log2_64(header.sh_addralign); 1939 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1940 this, // ObjectFile to which this section belongs and should read section data from. 1941 SectionIndex(I), // Section ID. 1942 name, // Section name. 1943 sect_type, // Section type. 1944 header.sh_addr, // VM address. 1945 vm_size, // VM size in bytes of this section. 1946 header.sh_offset, // Offset of this section in the file. 1947 file_size, // Size of the section as found in the file. 1948 log2align, // Alignment of the section 1949 header.sh_flags, // Flags for this section. 1950 target_bytes_size));// Number of host bytes per target byte 1951 1952 if (is_thread_specific) 1953 section_sp->SetIsThreadSpecific (is_thread_specific); 1954 m_sections_ap->AddSection(section_sp); 1955 } 1956 } 1957 1958 if (m_sections_ap.get()) 1959 { 1960 if (GetType() == eTypeDebugInfo) 1961 { 1962 static const SectionType g_sections[] = 1963 { 1964 eSectionTypeDWARFDebugAbbrev, 1965 eSectionTypeDWARFDebugAddr, 1966 eSectionTypeDWARFDebugAranges, 1967 eSectionTypeDWARFDebugFrame, 1968 eSectionTypeDWARFDebugInfo, 1969 eSectionTypeDWARFDebugLine, 1970 eSectionTypeDWARFDebugLoc, 1971 eSectionTypeDWARFDebugMacInfo, 1972 eSectionTypeDWARFDebugPubNames, 1973 eSectionTypeDWARFDebugPubTypes, 1974 eSectionTypeDWARFDebugRanges, 1975 eSectionTypeDWARFDebugStr, 1976 eSectionTypeDWARFDebugStrOffsets, 1977 eSectionTypeELFSymbolTable, 1978 }; 1979 SectionList *elf_section_list = m_sections_ap.get(); 1980 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1981 { 1982 SectionType section_type = g_sections[idx]; 1983 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1984 if (section_sp) 1985 { 1986 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1987 if (module_section_sp) 1988 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1989 else 1990 unified_section_list.AddSection (section_sp); 1991 } 1992 } 1993 } 1994 else 1995 { 1996 unified_section_list = *m_sections_ap; 1997 } 1998 } 1999 } 2000 2001 // Find the arm/aarch64 mapping symbol character in the given symbol name. Mapping symbols have the 2002 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping symbol prefixed by 2003 // an arbitrary string because if a symbol prefix added to each symbol in the object file with 2004 // objcopy then the mapping symbols are also prefixed. 2005 static char 2006 FindArmAarch64MappingSymbol(const char* symbol_name) 2007 { 2008 if (!symbol_name) 2009 return '\0'; 2010 2011 const char* dollar_pos = ::strchr(symbol_name, '$'); 2012 if (!dollar_pos || dollar_pos[1] == '\0') 2013 return '\0'; 2014 2015 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 2016 return dollar_pos[1]; 2017 return '\0'; 2018 } 2019 2020 #define STO_MIPS_ISA (3 << 6) 2021 #define STO_MICROMIPS (2 << 6) 2022 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER) & STO_MIPS_ISA) == STO_MICROMIPS) 2023 2024 // private 2025 unsigned 2026 ObjectFileELF::ParseSymbols (Symtab *symtab, 2027 user_id_t start_id, 2028 SectionList *section_list, 2029 const size_t num_symbols, 2030 const DataExtractor &symtab_data, 2031 const DataExtractor &strtab_data) 2032 { 2033 ELFSymbol symbol; 2034 lldb::offset_t offset = 0; 2035 2036 static ConstString text_section_name(".text"); 2037 static ConstString init_section_name(".init"); 2038 static ConstString fini_section_name(".fini"); 2039 static ConstString ctors_section_name(".ctors"); 2040 static ConstString dtors_section_name(".dtors"); 2041 2042 static ConstString data_section_name(".data"); 2043 static ConstString rodata_section_name(".rodata"); 2044 static ConstString rodata1_section_name(".rodata1"); 2045 static ConstString data2_section_name(".data1"); 2046 static ConstString bss_section_name(".bss"); 2047 static ConstString opd_section_name(".opd"); // For ppc64 2048 2049 // On Android the oatdata and the oatexec symbols in system@framework@boot.oat covers the full 2050 // .text section what causes issues with displaying unusable symbol name to the user and very 2051 // slow unwinding speed because the instruction emulation based unwind plans try to emulate all 2052 // instructions in these symbols. Don't add these symbols to the symbol list as they have no 2053 // use for the debugger and they are causing a lot of trouble. 2054 // Filtering can't be restricted to Android because this special object file don't contain the 2055 // note section specifying the environment to Android but the custom extension and file name 2056 // makes it highly unlikely that this will collide with anything else. 2057 bool skip_oatdata_oatexec = m_file.GetFilename() == ConstString("system@framework@boot.oat"); 2058 2059 ArchSpec arch; 2060 GetArchitecture(arch); 2061 2062 // Local cache to avoid doing a FindSectionByName for each symbol. The "const char*" key must 2063 // came from a ConstString object so they can be compared by pointer 2064 std::unordered_map<const char*, lldb::SectionSP> section_name_to_section; 2065 2066 unsigned i; 2067 for (i = 0; i < num_symbols; ++i) 2068 { 2069 if (symbol.Parse(symtab_data, &offset) == false) 2070 break; 2071 2072 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2073 2074 // No need to add non-section symbols that have no names 2075 if (symbol.getType() != STT_SECTION && 2076 (symbol_name == NULL || symbol_name[0] == '\0')) 2077 continue; 2078 2079 // Skipping oatdata and oatexec sections if it is requested. See details above the 2080 // definition of skip_oatdata_oatexec for the reasons. 2081 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0)) 2082 continue; 2083 2084 SectionSP symbol_section_sp; 2085 SymbolType symbol_type = eSymbolTypeInvalid; 2086 Elf64_Half symbol_idx = symbol.st_shndx; 2087 2088 switch (symbol_idx) 2089 { 2090 case SHN_ABS: 2091 symbol_type = eSymbolTypeAbsolute; 2092 break; 2093 case SHN_UNDEF: 2094 symbol_type = eSymbolTypeUndefined; 2095 break; 2096 default: 2097 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 2098 break; 2099 } 2100 2101 // If a symbol is undefined do not process it further even if it has a STT type 2102 if (symbol_type != eSymbolTypeUndefined) 2103 { 2104 switch (symbol.getType()) 2105 { 2106 default: 2107 case STT_NOTYPE: 2108 // The symbol's type is not specified. 2109 break; 2110 2111 case STT_OBJECT: 2112 // The symbol is associated with a data object, such as a variable, 2113 // an array, etc. 2114 symbol_type = eSymbolTypeData; 2115 break; 2116 2117 case STT_FUNC: 2118 // The symbol is associated with a function or other executable code. 2119 symbol_type = eSymbolTypeCode; 2120 break; 2121 2122 case STT_SECTION: 2123 // The symbol is associated with a section. Symbol table entries of 2124 // this type exist primarily for relocation and normally have 2125 // STB_LOCAL binding. 2126 break; 2127 2128 case STT_FILE: 2129 // Conventionally, the symbol's name gives the name of the source 2130 // file associated with the object file. A file symbol has STB_LOCAL 2131 // binding, its section index is SHN_ABS, and it precedes the other 2132 // STB_LOCAL symbols for the file, if it is present. 2133 symbol_type = eSymbolTypeSourceFile; 2134 break; 2135 2136 case STT_GNU_IFUNC: 2137 // The symbol is associated with an indirect function. The actual 2138 // function will be resolved if it is referenced. 2139 symbol_type = eSymbolTypeResolver; 2140 break; 2141 } 2142 } 2143 2144 if (symbol_type == eSymbolTypeInvalid) 2145 { 2146 if (symbol_section_sp) 2147 { 2148 const ConstString §_name = symbol_section_sp->GetName(); 2149 if (sect_name == text_section_name || 2150 sect_name == init_section_name || 2151 sect_name == fini_section_name || 2152 sect_name == ctors_section_name || 2153 sect_name == dtors_section_name) 2154 { 2155 symbol_type = eSymbolTypeCode; 2156 } 2157 else if (sect_name == data_section_name || 2158 sect_name == data2_section_name || 2159 sect_name == rodata_section_name || 2160 sect_name == rodata1_section_name || 2161 sect_name == bss_section_name) 2162 { 2163 symbol_type = eSymbolTypeData; 2164 } 2165 } 2166 } 2167 2168 int64_t symbol_value_offset = 0; 2169 uint32_t additional_flags = 0; 2170 2171 if (arch.IsValid()) 2172 { 2173 if (arch.GetMachine() == llvm::Triple::arm) 2174 { 2175 if (symbol.getBinding() == STB_LOCAL) 2176 { 2177 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2178 if (symbol_type == eSymbolTypeCode) 2179 { 2180 switch (mapping_symbol) 2181 { 2182 case 'a': 2183 // $a[.<any>]* - marks an ARM instruction sequence 2184 m_address_class_map[symbol.st_value] = eAddressClassCode; 2185 break; 2186 case 'b': 2187 case 't': 2188 // $b[.<any>]* - marks a THUMB BL instruction sequence 2189 // $t[.<any>]* - marks a THUMB instruction sequence 2190 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2191 break; 2192 case 'd': 2193 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2194 m_address_class_map[symbol.st_value] = eAddressClassData; 2195 break; 2196 } 2197 } 2198 if (mapping_symbol) 2199 continue; 2200 } 2201 } 2202 else if (arch.GetMachine() == llvm::Triple::aarch64) 2203 { 2204 if (symbol.getBinding() == STB_LOCAL) 2205 { 2206 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2207 if (symbol_type == eSymbolTypeCode) 2208 { 2209 switch (mapping_symbol) 2210 { 2211 case 'x': 2212 // $x[.<any>]* - marks an A64 instruction sequence 2213 m_address_class_map[symbol.st_value] = eAddressClassCode; 2214 break; 2215 case 'd': 2216 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2217 m_address_class_map[symbol.st_value] = eAddressClassData; 2218 break; 2219 } 2220 } 2221 if (mapping_symbol) 2222 continue; 2223 } 2224 } 2225 2226 if (arch.GetMachine() == llvm::Triple::arm) 2227 { 2228 if (symbol_type == eSymbolTypeCode) 2229 { 2230 if (symbol.st_value & 1) 2231 { 2232 // Subtracting 1 from the address effectively unsets 2233 // the low order bit, which results in the address 2234 // actually pointing to the beginning of the symbol. 2235 // This delta will be used below in conjunction with 2236 // symbol.st_value to produce the final symbol_value 2237 // that we store in the symtab. 2238 symbol_value_offset = -1; 2239 m_address_class_map[symbol.st_value^1] = eAddressClassCodeAlternateISA; 2240 } 2241 else 2242 { 2243 // This address is ARM 2244 m_address_class_map[symbol.st_value] = eAddressClassCode; 2245 } 2246 } 2247 } 2248 2249 /* 2250 * MIPS: 2251 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for MIPS). 2252 * This allows processer to switch between microMIPS and MIPS without any need 2253 * for special mode-control register. However, apart from .debug_line, none of 2254 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use st_other 2255 * flag to check whether the symbol is microMIPS and then set the address class 2256 * accordingly. 2257 */ 2258 const llvm::Triple::ArchType llvm_arch = arch.GetMachine(); 2259 if (llvm_arch == llvm::Triple::mips || llvm_arch == llvm::Triple::mipsel 2260 || llvm_arch == llvm::Triple::mips64 || llvm_arch == llvm::Triple::mips64el) 2261 { 2262 if (IS_MICROMIPS(symbol.st_other)) 2263 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2264 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) 2265 { 2266 symbol.st_value = symbol.st_value & (~1ull); 2267 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2268 } 2269 else 2270 { 2271 if (symbol_type == eSymbolTypeCode) 2272 m_address_class_map[symbol.st_value] = eAddressClassCode; 2273 else if (symbol_type == eSymbolTypeData) 2274 m_address_class_map[symbol.st_value] = eAddressClassData; 2275 else 2276 m_address_class_map[symbol.st_value] = eAddressClassUnknown; 2277 } 2278 } 2279 } 2280 2281 // symbol_value_offset may contain 0 for ARM symbols or -1 for 2282 // THUMB symbols. See above for more details. 2283 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2284 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 2285 symbol_value -= symbol_section_sp->GetFileAddress(); 2286 2287 if (symbol_section_sp) 2288 { 2289 ModuleSP module_sp(GetModule()); 2290 if (module_sp) 2291 { 2292 SectionList *module_section_list = module_sp->GetSectionList(); 2293 if (module_section_list && module_section_list != section_list) 2294 { 2295 const ConstString §_name = symbol_section_sp->GetName(); 2296 auto section_it = section_name_to_section.find(sect_name.GetCString()); 2297 if (section_it == section_name_to_section.end()) 2298 section_it = section_name_to_section.emplace( 2299 sect_name.GetCString(), 2300 module_section_list->FindSectionByName (sect_name)).first; 2301 if (section_it->second && section_it->second->GetFileSize()) 2302 symbol_section_sp = section_it->second; 2303 } 2304 } 2305 } 2306 2307 bool is_global = symbol.getBinding() == STB_GLOBAL; 2308 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2309 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2310 2311 llvm::StringRef symbol_ref(symbol_name); 2312 2313 // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily. 2314 size_t version_pos = symbol_ref.find('@'); 2315 bool has_suffix = version_pos != llvm::StringRef::npos; 2316 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2317 Mangled mangled(ConstString(symbol_bare), is_mangled); 2318 2319 // Now append the suffix back to mangled and unmangled names. Only do it if the 2320 // demangling was successful (string is not empty). 2321 if (has_suffix) 2322 { 2323 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2324 2325 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2326 if (! mangled_name.empty()) 2327 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) ); 2328 2329 ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeUnknown); 2330 llvm::StringRef demangled_name = demangled.GetStringRef(); 2331 if (!demangled_name.empty()) 2332 mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) ); 2333 } 2334 2335 // In ELF all symbol should have a valid size but it is not true for some code symbols 2336 // coming from hand written assembly. As none of the code symbol should have 0 size we try 2337 // to calculate the size for these symbols in the symtab with saying that their original 2338 // size is not valid. 2339 bool symbol_size_valid = symbol.st_size != 0 || symbol_type != eSymbolTypeCode; 2340 2341 Symbol dc_symbol( 2342 i + start_id, // ID is the original symbol table index. 2343 mangled, 2344 symbol_type, // Type of this symbol 2345 is_global, // Is this globally visible? 2346 false, // Is this symbol debug info? 2347 false, // Is this symbol a trampoline? 2348 false, // Is this symbol artificial? 2349 AddressRange( 2350 symbol_section_sp, // Section in which this symbol is defined or null. 2351 symbol_value, // Offset in section or symbol value. 2352 symbol.st_size), // Size in bytes of this symbol. 2353 symbol_size_valid, // Symbol size is valid 2354 has_suffix, // Contains linker annotations? 2355 flags); // Symbol flags. 2356 symtab->AddSymbol(dc_symbol); 2357 } 2358 return i; 2359 } 2360 2361 unsigned 2362 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, 2363 user_id_t start_id, 2364 lldb_private::Section *symtab) 2365 { 2366 if (symtab->GetObjectFile() != this) 2367 { 2368 // If the symbol table section is owned by a different object file, have it do the 2369 // parsing. 2370 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2371 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 2372 } 2373 2374 // Get section list for this object file. 2375 SectionList *section_list = m_sections_ap.get(); 2376 if (!section_list) 2377 return 0; 2378 2379 user_id_t symtab_id = symtab->GetID(); 2380 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2381 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2382 symtab_hdr->sh_type == SHT_DYNSYM); 2383 2384 // sh_link: section header index of associated string table. 2385 // Section ID's are ones based. 2386 user_id_t strtab_id = symtab_hdr->sh_link + 1; 2387 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2388 2389 if (symtab && strtab) 2390 { 2391 assert (symtab->GetObjectFile() == this); 2392 assert (strtab->GetObjectFile() == this); 2393 2394 DataExtractor symtab_data; 2395 DataExtractor strtab_data; 2396 if (ReadSectionData(symtab, symtab_data) && 2397 ReadSectionData(strtab, strtab_data)) 2398 { 2399 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2400 2401 return ParseSymbols(symbol_table, start_id, section_list, 2402 num_symbols, symtab_data, strtab_data); 2403 } 2404 } 2405 2406 return 0; 2407 } 2408 2409 size_t 2410 ObjectFileELF::ParseDynamicSymbols() 2411 { 2412 if (m_dynamic_symbols.size()) 2413 return m_dynamic_symbols.size(); 2414 2415 SectionList *section_list = GetSectionList(); 2416 if (!section_list) 2417 return 0; 2418 2419 // Find the SHT_DYNAMIC section. 2420 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 2421 if (!dynsym) 2422 return 0; 2423 assert (dynsym->GetObjectFile() == this); 2424 2425 ELFDynamic symbol; 2426 DataExtractor dynsym_data; 2427 if (ReadSectionData(dynsym, dynsym_data)) 2428 { 2429 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2430 lldb::offset_t cursor = 0; 2431 2432 while (cursor < section_size) 2433 { 2434 if (!symbol.Parse(dynsym_data, &cursor)) 2435 break; 2436 2437 m_dynamic_symbols.push_back(symbol); 2438 } 2439 } 2440 2441 return m_dynamic_symbols.size(); 2442 } 2443 2444 const ELFDynamic * 2445 ObjectFileELF::FindDynamicSymbol(unsigned tag) 2446 { 2447 if (!ParseDynamicSymbols()) 2448 return NULL; 2449 2450 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2451 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2452 for ( ; I != E; ++I) 2453 { 2454 ELFDynamic *symbol = &*I; 2455 2456 if (symbol->d_tag == tag) 2457 return symbol; 2458 } 2459 2460 return NULL; 2461 } 2462 2463 unsigned 2464 ObjectFileELF::PLTRelocationType() 2465 { 2466 // DT_PLTREL 2467 // This member specifies the type of relocation entry to which the 2468 // procedure linkage table refers. The d_val member holds DT_REL or 2469 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2470 // must use the same relocation. 2471 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2472 2473 if (symbol) 2474 return symbol->d_val; 2475 2476 return 0; 2477 } 2478 2479 // Returns the size of the normal plt entries and the offset of the first normal plt entry. The 2480 // 0th entry in the plt table is usually a resolution entry which have different size in some 2481 // architectures then the rest of the plt entries. 2482 static std::pair<uint64_t, uint64_t> 2483 GetPltEntrySizeAndOffset(const ELFSectionHeader* rel_hdr, const ELFSectionHeader* plt_hdr) 2484 { 2485 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2486 2487 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 2488 // So round the entsize up by the alignment if addralign is set. 2489 elf_xword plt_entsize = plt_hdr->sh_addralign ? 2490 llvm::alignTo (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 2491 2492 if (plt_entsize == 0) 2493 { 2494 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the size of the plt 2495 // entries based on the number of entries and the size of the plt section with the 2496 // assumption that the size of the 0th entry is at least as big as the size of the normal 2497 // entries and it isn't much bigger then that. 2498 if (plt_hdr->sh_addralign) 2499 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign; 2500 else 2501 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2502 } 2503 2504 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2505 2506 return std::make_pair(plt_entsize, plt_offset); 2507 } 2508 2509 static unsigned 2510 ParsePLTRelocations(Symtab *symbol_table, 2511 user_id_t start_id, 2512 unsigned rel_type, 2513 const ELFHeader *hdr, 2514 const ELFSectionHeader *rel_hdr, 2515 const ELFSectionHeader *plt_hdr, 2516 const ELFSectionHeader *sym_hdr, 2517 const lldb::SectionSP &plt_section_sp, 2518 DataExtractor &rel_data, 2519 DataExtractor &symtab_data, 2520 DataExtractor &strtab_data) 2521 { 2522 ELFRelocation rel(rel_type); 2523 ELFSymbol symbol; 2524 lldb::offset_t offset = 0; 2525 2526 uint64_t plt_offset, plt_entsize; 2527 std::tie(plt_entsize, plt_offset) = GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2528 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2529 2530 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2531 reloc_info_fn reloc_type; 2532 reloc_info_fn reloc_symbol; 2533 2534 if (hdr->Is32Bit()) 2535 { 2536 reloc_type = ELFRelocation::RelocType32; 2537 reloc_symbol = ELFRelocation::RelocSymbol32; 2538 } 2539 else 2540 { 2541 reloc_type = ELFRelocation::RelocType64; 2542 reloc_symbol = ELFRelocation::RelocSymbol64; 2543 } 2544 2545 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2546 unsigned i; 2547 for (i = 0; i < num_relocations; ++i) 2548 { 2549 if (rel.Parse(rel_data, &offset) == false) 2550 break; 2551 2552 if (reloc_type(rel) != slot_type) 2553 continue; 2554 2555 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2556 if (!symbol.Parse(symtab_data, &symbol_offset)) 2557 break; 2558 2559 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2560 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2561 uint64_t plt_index = plt_offset + i * plt_entsize; 2562 2563 Symbol jump_symbol( 2564 i + start_id, // Symbol table index 2565 symbol_name, // symbol name. 2566 is_mangled, // is the symbol name mangled? 2567 eSymbolTypeTrampoline, // Type of this symbol 2568 false, // Is this globally visible? 2569 false, // Is this symbol debug info? 2570 true, // Is this symbol a trampoline? 2571 true, // Is this symbol artificial? 2572 plt_section_sp, // Section in which this symbol is defined or null. 2573 plt_index, // Offset in section or symbol value. 2574 plt_entsize, // Size in bytes of this symbol. 2575 true, // Size is valid 2576 false, // Contains linker annotations? 2577 0); // Symbol flags. 2578 2579 symbol_table->AddSymbol(jump_symbol); 2580 } 2581 2582 return i; 2583 } 2584 2585 unsigned 2586 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2587 user_id_t start_id, 2588 const ELFSectionHeaderInfo *rel_hdr, 2589 user_id_t rel_id) 2590 { 2591 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2592 2593 // The link field points to the associated symbol table. The info field 2594 // points to the section holding the plt. 2595 user_id_t symtab_id = rel_hdr->sh_link; 2596 user_id_t plt_id = rel_hdr->sh_info; 2597 2598 // If the link field doesn't point to the appropriate symbol name table then 2599 // try to find it by name as some compiler don't fill in the link fields. 2600 if (!symtab_id) 2601 symtab_id = GetSectionIndexByName(".dynsym"); 2602 if (!plt_id) 2603 plt_id = GetSectionIndexByName(".plt"); 2604 2605 if (!symtab_id || !plt_id) 2606 return 0; 2607 2608 // Section ID's are ones based; 2609 symtab_id++; 2610 plt_id++; 2611 2612 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2613 if (!plt_hdr) 2614 return 0; 2615 2616 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2617 if (!sym_hdr) 2618 return 0; 2619 2620 SectionList *section_list = m_sections_ap.get(); 2621 if (!section_list) 2622 return 0; 2623 2624 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2625 if (!rel_section) 2626 return 0; 2627 2628 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2629 if (!plt_section_sp) 2630 return 0; 2631 2632 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2633 if (!symtab) 2634 return 0; 2635 2636 // sh_link points to associated string table. 2637 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2638 if (!strtab) 2639 return 0; 2640 2641 DataExtractor rel_data; 2642 if (!ReadSectionData(rel_section, rel_data)) 2643 return 0; 2644 2645 DataExtractor symtab_data; 2646 if (!ReadSectionData(symtab, symtab_data)) 2647 return 0; 2648 2649 DataExtractor strtab_data; 2650 if (!ReadSectionData(strtab, strtab_data)) 2651 return 0; 2652 2653 unsigned rel_type = PLTRelocationType(); 2654 if (!rel_type) 2655 return 0; 2656 2657 return ParsePLTRelocations (symbol_table, 2658 start_id, 2659 rel_type, 2660 &m_header, 2661 rel_hdr, 2662 plt_hdr, 2663 sym_hdr, 2664 plt_section_sp, 2665 rel_data, 2666 symtab_data, 2667 strtab_data); 2668 } 2669 2670 unsigned 2671 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2672 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2673 DataExtractor &rel_data, DataExtractor &symtab_data, 2674 DataExtractor &debug_data, Section* rel_section) 2675 { 2676 ELFRelocation rel(rel_hdr->sh_type); 2677 lldb::addr_t offset = 0; 2678 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2679 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2680 reloc_info_fn reloc_type; 2681 reloc_info_fn reloc_symbol; 2682 2683 if (hdr->Is32Bit()) 2684 { 2685 reloc_type = ELFRelocation::RelocType32; 2686 reloc_symbol = ELFRelocation::RelocSymbol32; 2687 } 2688 else 2689 { 2690 reloc_type = ELFRelocation::RelocType64; 2691 reloc_symbol = ELFRelocation::RelocSymbol64; 2692 } 2693 2694 for (unsigned i = 0; i < num_relocations; ++i) 2695 { 2696 if (rel.Parse(rel_data, &offset) == false) 2697 break; 2698 2699 Symbol* symbol = NULL; 2700 2701 if (hdr->Is32Bit()) 2702 { 2703 switch (reloc_type(rel)) { 2704 case R_386_32: 2705 case R_386_PC32: 2706 default: 2707 assert(false && "unexpected relocation type"); 2708 } 2709 } else { 2710 switch (reloc_type(rel)) { 2711 case R_X86_64_64: 2712 { 2713 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2714 if (symbol) 2715 { 2716 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2717 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2718 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2719 *dst = value + ELFRelocation::RelocAddend64(rel); 2720 } 2721 break; 2722 } 2723 case R_X86_64_32: 2724 case R_X86_64_32S: 2725 { 2726 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2727 if (symbol) 2728 { 2729 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2730 value += ELFRelocation::RelocAddend32(rel); 2731 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2732 (reloc_type(rel) == R_X86_64_32S && 2733 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2734 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2735 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2736 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2737 *dst = truncated_addr; 2738 } 2739 break; 2740 } 2741 case R_X86_64_PC32: 2742 default: 2743 assert(false && "unexpected relocation type"); 2744 } 2745 } 2746 } 2747 2748 return 0; 2749 } 2750 2751 unsigned 2752 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2753 { 2754 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2755 2756 // Parse in the section list if needed. 2757 SectionList *section_list = GetSectionList(); 2758 if (!section_list) 2759 return 0; 2760 2761 // Section ID's are ones based. 2762 user_id_t symtab_id = rel_hdr->sh_link + 1; 2763 user_id_t debug_id = rel_hdr->sh_info + 1; 2764 2765 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2766 if (!symtab_hdr) 2767 return 0; 2768 2769 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2770 if (!debug_hdr) 2771 return 0; 2772 2773 Section *rel = section_list->FindSectionByID(rel_id).get(); 2774 if (!rel) 2775 return 0; 2776 2777 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2778 if (!symtab) 2779 return 0; 2780 2781 Section *debug = section_list->FindSectionByID(debug_id).get(); 2782 if (!debug) 2783 return 0; 2784 2785 DataExtractor rel_data; 2786 DataExtractor symtab_data; 2787 DataExtractor debug_data; 2788 2789 if (ReadSectionData(rel, rel_data) && 2790 ReadSectionData(symtab, symtab_data) && 2791 ReadSectionData(debug, debug_data)) 2792 { 2793 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2794 rel_data, symtab_data, debug_data, debug); 2795 } 2796 2797 return 0; 2798 } 2799 2800 Symtab * 2801 ObjectFileELF::GetSymtab() 2802 { 2803 ModuleSP module_sp(GetModule()); 2804 if (!module_sp) 2805 return NULL; 2806 2807 // We always want to use the main object file so we (hopefully) only have one cached copy 2808 // of our symtab, dynamic sections, etc. 2809 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2810 if (module_obj_file && module_obj_file != this) 2811 return module_obj_file->GetSymtab(); 2812 2813 if (m_symtab_ap.get() == NULL) 2814 { 2815 SectionList *section_list = module_sp->GetSectionList(); 2816 if (!section_list) 2817 return NULL; 2818 2819 uint64_t symbol_id = 0; 2820 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2821 2822 // Sharable objects and dynamic executables usually have 2 distinct symbol 2823 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2824 // version of the symtab that only contains global symbols. The information found 2825 // in the dynsym is therefore also found in the symtab, while the reverse is not 2826 // necessarily true. 2827 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2828 if (!symtab) 2829 { 2830 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2831 // then use the dynsym section which should always be there. 2832 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2833 } 2834 if (symtab) 2835 { 2836 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile())); 2837 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2838 } 2839 2840 // DT_JMPREL 2841 // If present, this entry's d_ptr member holds the address of relocation 2842 // entries associated solely with the procedure linkage table. Separating 2843 // these relocation entries lets the dynamic linker ignore them during 2844 // process initialization, if lazy binding is enabled. If this entry is 2845 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2846 // also be present. 2847 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2848 if (symbol) 2849 { 2850 // Synthesize trampoline symbols to help navigate the PLT. 2851 addr_t addr = symbol->d_ptr; 2852 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2853 if (reloc_section) 2854 { 2855 user_id_t reloc_id = reloc_section->GetID(); 2856 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2857 assert(reloc_header); 2858 2859 if (m_symtab_ap == nullptr) 2860 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile())); 2861 2862 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2863 } 2864 } 2865 2866 // If we still don't have any symtab then create an empty instance to avoid do the section 2867 // lookup next time. 2868 if (m_symtab_ap == nullptr) 2869 m_symtab_ap.reset(new Symtab(this)); 2870 2871 m_symtab_ap->CalculateSymbolSizes(); 2872 } 2873 2874 for (SectionHeaderCollIter I = m_section_headers.begin(); 2875 I != m_section_headers.end(); ++I) 2876 { 2877 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2878 { 2879 if (CalculateType() == eTypeObjectFile) 2880 { 2881 const char *section_name = I->section_name.AsCString(""); 2882 if (strstr(section_name, ".rela.debug") || 2883 strstr(section_name, ".rel.debug")) 2884 { 2885 const ELFSectionHeader &reloc_header = *I; 2886 user_id_t reloc_id = SectionIndex(I); 2887 RelocateDebugSections(&reloc_header, reloc_id); 2888 } 2889 } 2890 } 2891 } 2892 return m_symtab_ap.get(); 2893 } 2894 2895 Symbol * 2896 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2897 { 2898 if (!m_symtab_ap.get()) 2899 return nullptr; // GetSymtab() should be called first. 2900 2901 const SectionList *section_list = GetSectionList(); 2902 if (!section_list) 2903 return nullptr; 2904 2905 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2906 { 2907 AddressRange range; 2908 if (eh_frame->GetAddressRange (so_addr, range)) 2909 { 2910 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2911 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2912 if (symbol) 2913 return symbol; 2914 2915 // Note that a (stripped) symbol won't be found by GetSymtab()... 2916 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2917 if (eh_sym_section_sp.get()) 2918 { 2919 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2920 addr_t offset = file_addr - section_base; 2921 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2922 2923 Symbol eh_symbol( 2924 symbol_id, // Symbol table index. 2925 "???", // Symbol name. 2926 false, // Is the symbol name mangled? 2927 eSymbolTypeCode, // Type of this symbol. 2928 true, // Is this globally visible? 2929 false, // Is this symbol debug info? 2930 false, // Is this symbol a trampoline? 2931 true, // Is this symbol artificial? 2932 eh_sym_section_sp, // Section in which this symbol is defined or null. 2933 offset, // Offset in section or symbol value. 2934 range.GetByteSize(), // Size in bytes of this symbol. 2935 true, // Size is valid. 2936 false, // Contains linker annotations? 2937 0); // Symbol flags. 2938 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2939 return m_symtab_ap->SymbolAtIndex(symbol_id); 2940 } 2941 } 2942 } 2943 return nullptr; 2944 } 2945 2946 2947 bool 2948 ObjectFileELF::IsStripped () 2949 { 2950 // TODO: determine this for ELF 2951 return false; 2952 } 2953 2954 //===----------------------------------------------------------------------===// 2955 // Dump 2956 // 2957 // Dump the specifics of the runtime file container (such as any headers 2958 // segments, sections, etc). 2959 //---------------------------------------------------------------------- 2960 void 2961 ObjectFileELF::Dump(Stream *s) 2962 { 2963 DumpELFHeader(s, m_header); 2964 s->EOL(); 2965 DumpELFProgramHeaders(s); 2966 s->EOL(); 2967 DumpELFSectionHeaders(s); 2968 s->EOL(); 2969 SectionList *section_list = GetSectionList(); 2970 if (section_list) 2971 section_list->Dump(s, NULL, true, UINT32_MAX); 2972 Symtab *symtab = GetSymtab(); 2973 if (symtab) 2974 symtab->Dump(s, NULL, eSortOrderNone); 2975 s->EOL(); 2976 DumpDependentModules(s); 2977 s->EOL(); 2978 } 2979 2980 //---------------------------------------------------------------------- 2981 // DumpELFHeader 2982 // 2983 // Dump the ELF header to the specified output stream 2984 //---------------------------------------------------------------------- 2985 void 2986 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2987 { 2988 s->PutCString("ELF Header\n"); 2989 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2990 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2991 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2992 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2993 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2994 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2995 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2996 2997 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2998 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2999 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 3000 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 3001 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 3002 3003 s->Printf("e_type = 0x%4.4x ", header.e_type); 3004 DumpELFHeader_e_type(s, header.e_type); 3005 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 3006 s->Printf("e_version = 0x%8.8x\n", header.e_version); 3007 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 3008 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 3009 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 3010 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 3011 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 3012 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 3013 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 3014 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 3015 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 3016 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 3017 } 3018 3019 //---------------------------------------------------------------------- 3020 // DumpELFHeader_e_type 3021 // 3022 // Dump an token value for the ELF header member e_type 3023 //---------------------------------------------------------------------- 3024 void 3025 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 3026 { 3027 switch (e_type) 3028 { 3029 case ET_NONE: *s << "ET_NONE"; break; 3030 case ET_REL: *s << "ET_REL"; break; 3031 case ET_EXEC: *s << "ET_EXEC"; break; 3032 case ET_DYN: *s << "ET_DYN"; break; 3033 case ET_CORE: *s << "ET_CORE"; break; 3034 default: 3035 break; 3036 } 3037 } 3038 3039 //---------------------------------------------------------------------- 3040 // DumpELFHeader_e_ident_EI_DATA 3041 // 3042 // Dump an token value for the ELF header member e_ident[EI_DATA] 3043 //---------------------------------------------------------------------- 3044 void 3045 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 3046 { 3047 switch (ei_data) 3048 { 3049 case ELFDATANONE: *s << "ELFDATANONE"; break; 3050 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 3051 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 3052 default: 3053 break; 3054 } 3055 } 3056 3057 3058 //---------------------------------------------------------------------- 3059 // DumpELFProgramHeader 3060 // 3061 // Dump a single ELF program header to the specified output stream 3062 //---------------------------------------------------------------------- 3063 void 3064 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 3065 { 3066 DumpELFProgramHeader_p_type(s, ph.p_type); 3067 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 3068 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 3069 3070 DumpELFProgramHeader_p_flags(s, ph.p_flags); 3071 s->Printf(") %8.8" PRIx64, ph.p_align); 3072 } 3073 3074 //---------------------------------------------------------------------- 3075 // DumpELFProgramHeader_p_type 3076 // 3077 // Dump an token value for the ELF program header member p_type which 3078 // describes the type of the program header 3079 // ---------------------------------------------------------------------- 3080 void 3081 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 3082 { 3083 const int kStrWidth = 15; 3084 switch (p_type) 3085 { 3086 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 3087 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 3088 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 3089 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 3090 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 3091 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 3092 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 3093 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 3094 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 3095 default: 3096 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 3097 break; 3098 } 3099 } 3100 3101 3102 //---------------------------------------------------------------------- 3103 // DumpELFProgramHeader_p_flags 3104 // 3105 // Dump an token value for the ELF program header member p_flags 3106 //---------------------------------------------------------------------- 3107 void 3108 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 3109 { 3110 *s << ((p_flags & PF_X) ? "PF_X" : " ") 3111 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 3112 << ((p_flags & PF_W) ? "PF_W" : " ") 3113 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 3114 << ((p_flags & PF_R) ? "PF_R" : " "); 3115 } 3116 3117 //---------------------------------------------------------------------- 3118 // DumpELFProgramHeaders 3119 // 3120 // Dump all of the ELF program header to the specified output stream 3121 //---------------------------------------------------------------------- 3122 void 3123 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 3124 { 3125 if (!ParseProgramHeaders()) 3126 return; 3127 3128 s->PutCString("Program Headers\n"); 3129 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 3130 "p_filesz p_memsz p_flags p_align\n"); 3131 s->PutCString("==== --------------- -------- -------- -------- " 3132 "-------- -------- ------------------------- --------\n"); 3133 3134 uint32_t idx = 0; 3135 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 3136 I != m_program_headers.end(); ++I, ++idx) 3137 { 3138 s->Printf("[%2u] ", idx); 3139 ObjectFileELF::DumpELFProgramHeader(s, *I); 3140 s->EOL(); 3141 } 3142 } 3143 3144 //---------------------------------------------------------------------- 3145 // DumpELFSectionHeader 3146 // 3147 // Dump a single ELF section header to the specified output stream 3148 //---------------------------------------------------------------------- 3149 void 3150 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 3151 { 3152 s->Printf("%8.8x ", sh.sh_name); 3153 DumpELFSectionHeader_sh_type(s, sh.sh_type); 3154 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 3155 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 3156 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 3157 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 3158 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 3159 } 3160 3161 //---------------------------------------------------------------------- 3162 // DumpELFSectionHeader_sh_type 3163 // 3164 // Dump an token value for the ELF section header member sh_type which 3165 // describes the type of the section 3166 //---------------------------------------------------------------------- 3167 void 3168 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 3169 { 3170 const int kStrWidth = 12; 3171 switch (sh_type) 3172 { 3173 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 3174 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 3175 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 3176 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 3177 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 3178 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 3179 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 3180 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 3181 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 3182 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 3183 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 3184 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 3185 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 3186 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 3187 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 3188 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 3189 default: 3190 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 3191 break; 3192 } 3193 } 3194 3195 //---------------------------------------------------------------------- 3196 // DumpELFSectionHeader_sh_flags 3197 // 3198 // Dump an token value for the ELF section header member sh_flags 3199 //---------------------------------------------------------------------- 3200 void 3201 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 3202 { 3203 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3204 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3205 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3206 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3207 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3208 } 3209 3210 //---------------------------------------------------------------------- 3211 // DumpELFSectionHeaders 3212 // 3213 // Dump all of the ELF section header to the specified output stream 3214 //---------------------------------------------------------------------- 3215 void 3216 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 3217 { 3218 if (!ParseSectionHeaders()) 3219 return; 3220 3221 s->PutCString("Section Headers\n"); 3222 s->PutCString("IDX name type flags " 3223 "addr offset size link info addralgn " 3224 "entsize Name\n"); 3225 s->PutCString("==== -------- ------------ -------------------------------- " 3226 "-------- -------- -------- -------- -------- -------- " 3227 "-------- ====================\n"); 3228 3229 uint32_t idx = 0; 3230 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3231 I != m_section_headers.end(); ++I, ++idx) 3232 { 3233 s->Printf("[%2u] ", idx); 3234 ObjectFileELF::DumpELFSectionHeader(s, *I); 3235 const char* section_name = I->section_name.AsCString(""); 3236 if (section_name) 3237 *s << ' ' << section_name << "\n"; 3238 } 3239 } 3240 3241 void 3242 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 3243 { 3244 size_t num_modules = ParseDependentModules(); 3245 3246 if (num_modules > 0) 3247 { 3248 s->PutCString("Dependent Modules:\n"); 3249 for (unsigned i = 0; i < num_modules; ++i) 3250 { 3251 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 3252 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3253 } 3254 } 3255 } 3256 3257 bool 3258 ObjectFileELF::GetArchitecture (ArchSpec &arch) 3259 { 3260 if (!ParseHeader()) 3261 return false; 3262 3263 if (m_section_headers.empty()) 3264 { 3265 // Allow elf notes to be parsed which may affect the detected architecture. 3266 ParseSectionHeaders(); 3267 } 3268 3269 if (CalculateType() == eTypeCoreFile && m_arch_spec.TripleOSIsUnspecifiedUnknown()) 3270 { 3271 // Core files don't have section headers yet they have PT_NOTE program headers 3272 // that might shed more light on the architecture 3273 if (ParseProgramHeaders()) 3274 { 3275 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) 3276 { 3277 const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i); 3278 if (header && header->p_type == PT_NOTE && header->p_offset != 0 && header->p_filesz > 0) 3279 { 3280 DataExtractor data; 3281 if (data.SetData (m_data, header->p_offset, header->p_filesz) == header->p_filesz) 3282 { 3283 lldb_private::UUID uuid; 3284 RefineModuleDetailsFromNote (data, m_arch_spec, uuid); 3285 } 3286 } 3287 } 3288 } 3289 } 3290 arch = m_arch_spec; 3291 return true; 3292 } 3293 3294 ObjectFile::Type 3295 ObjectFileELF::CalculateType() 3296 { 3297 switch (m_header.e_type) 3298 { 3299 case llvm::ELF::ET_NONE: 3300 // 0 - No file type 3301 return eTypeUnknown; 3302 3303 case llvm::ELF::ET_REL: 3304 // 1 - Relocatable file 3305 return eTypeObjectFile; 3306 3307 case llvm::ELF::ET_EXEC: 3308 // 2 - Executable file 3309 return eTypeExecutable; 3310 3311 case llvm::ELF::ET_DYN: 3312 // 3 - Shared object file 3313 return eTypeSharedLibrary; 3314 3315 case ET_CORE: 3316 // 4 - Core file 3317 return eTypeCoreFile; 3318 3319 default: 3320 break; 3321 } 3322 return eTypeUnknown; 3323 } 3324 3325 ObjectFile::Strata 3326 ObjectFileELF::CalculateStrata() 3327 { 3328 switch (m_header.e_type) 3329 { 3330 case llvm::ELF::ET_NONE: 3331 // 0 - No file type 3332 return eStrataUnknown; 3333 3334 case llvm::ELF::ET_REL: 3335 // 1 - Relocatable file 3336 return eStrataUnknown; 3337 3338 case llvm::ELF::ET_EXEC: 3339 // 2 - Executable file 3340 // TODO: is there any way to detect that an executable is a kernel 3341 // related executable by inspecting the program headers, section 3342 // headers, symbols, or any other flag bits??? 3343 return eStrataUser; 3344 3345 case llvm::ELF::ET_DYN: 3346 // 3 - Shared object file 3347 // TODO: is there any way to detect that an shared library is a kernel 3348 // related executable by inspecting the program headers, section 3349 // headers, symbols, or any other flag bits??? 3350 return eStrataUnknown; 3351 3352 case ET_CORE: 3353 // 4 - Core file 3354 // TODO: is there any way to detect that an core file is a kernel 3355 // related executable by inspecting the program headers, section 3356 // headers, symbols, or any other flag bits??? 3357 return eStrataUnknown; 3358 3359 default: 3360 break; 3361 } 3362 return eStrataUnknown; 3363 } 3364 3365