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