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