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