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